core.c 194 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145614661476148614961506151615261536154615561566157615861596160616161626163616461656166616761686169617061716172617361746175617661776178617961806181618261836184618561866187618861896190619161926193619461956196619761986199620062016202620362046205620662076208620962106211621262136214621562166217621862196220622162226223622462256226622762286229623062316232623362346235623662376238623962406241624262436244624562466247624862496250625162526253625462556256625762586259626062616262626362646265626662676268626962706271627262736274627562766277627862796280628162826283628462856286628762886289629062916292629362946295629662976298629963006301630263036304630563066307630863096310631163126313631463156316631763186319632063216322632363246325632663276328632963306331633263336334633563366337633863396340634163426343634463456346634763486349635063516352635363546355635663576358635963606361636263636364636563666367636863696370637163726373637463756376637763786379638063816382638363846385638663876388638963906391639263936394639563966397639863996400640164026403640464056406640764086409641064116412641364146415641664176418641964206421642264236424642564266427642864296430643164326433643464356436643764386439644064416442644364446445644664476448644964506451645264536454645564566457645864596460646164626463646464656466646764686469647064716472647364746475647664776478647964806481648264836484648564866487648864896490649164926493649464956496649764986499650065016502650365046505650665076508650965106511651265136514651565166517651865196520652165226523652465256526652765286529653065316532653365346535653665376538653965406541654265436544654565466547654865496550655165526553655465556556655765586559656065616562656365646565656665676568656965706571657265736574657565766577657865796580658165826583658465856586658765886589659065916592659365946595659665976598659966006601660266036604660566066607660866096610661166126613661466156616661766186619662066216622662366246625662666276628662966306631663266336634663566366637663866396640664166426643664466456646664766486649665066516652665366546655665666576658665966606661666266636664666566666667666866696670667166726673667466756676667766786679668066816682668366846685668666876688668966906691669266936694669566966697669866996700670167026703670467056706670767086709671067116712671367146715671667176718671967206721672267236724672567266727672867296730673167326733673467356736673767386739674067416742674367446745674667476748674967506751675267536754675567566757675867596760676167626763676467656766676767686769677067716772677367746775677667776778677967806781678267836784678567866787678867896790679167926793679467956796679767986799680068016802680368046805680668076808680968106811681268136814681568166817681868196820682168226823682468256826682768286829683068316832683368346835683668376838683968406841684268436844684568466847684868496850685168526853685468556856685768586859686068616862686368646865686668676868686968706871687268736874687568766877687868796880688168826883688468856886688768886889689068916892689368946895689668976898689969006901690269036904690569066907690869096910691169126913691469156916691769186919692069216922692369246925692669276928692969306931693269336934693569366937693869396940694169426943694469456946694769486949695069516952695369546955695669576958695969606961696269636964696569666967696869696970697169726973697469756976697769786979698069816982698369846985698669876988698969906991699269936994699569966997699869997000700170027003700470057006700770087009701070117012701370147015701670177018701970207021702270237024702570267027702870297030703170327033703470357036703770387039704070417042704370447045704670477048704970507051705270537054705570567057705870597060706170627063706470657066706770687069707070717072707370747075707670777078707970807081708270837084708570867087708870897090709170927093709470957096709770987099710071017102710371047105710671077108710971107111711271137114711571167117711871197120712171227123712471257126712771287129713071317132713371347135713671377138713971407141714271437144714571467147714871497150715171527153715471557156715771587159716071617162716371647165716671677168716971707171717271737174717571767177717871797180718171827183718471857186718771887189719071917192719371947195719671977198719972007201720272037204720572067207720872097210721172127213721472157216721772187219722072217222722372247225722672277228722972307231723272337234723572367237723872397240724172427243724472457246724772487249725072517252725372547255725672577258725972607261726272637264726572667267726872697270727172727273727472757276727772787279728072817282728372847285728672877288728972907291729272937294729572967297729872997300730173027303730473057306730773087309731073117312731373147315731673177318731973207321732273237324732573267327732873297330733173327333733473357336733773387339734073417342734373447345734673477348734973507351735273537354735573567357735873597360736173627363736473657366736773687369737073717372737373747375737673777378737973807381738273837384738573867387738873897390739173927393739473957396739773987399740074017402740374047405740674077408740974107411741274137414741574167417741874197420742174227423742474257426742774287429743074317432743374347435743674377438743974407441744274437444744574467447744874497450745174527453745474557456745774587459746074617462746374647465746674677468746974707471747274737474747574767477747874797480748174827483748474857486748774887489749074917492749374947495749674977498749975007501750275037504750575067507750875097510751175127513751475157516751775187519752075217522752375247525752675277528752975307531753275337534753575367537753875397540754175427543754475457546754775487549755075517552755375547555755675577558755975607561756275637564756575667567756875697570757175727573757475757576757775787579758075817582758375847585758675877588758975907591759275937594759575967597759875997600760176027603760476057606760776087609761076117612761376147615761676177618761976207621762276237624762576267627762876297630763176327633763476357636763776387639764076417642764376447645764676477648764976507651765276537654765576567657765876597660766176627663766476657666766776687669767076717672767376747675767676777678767976807681768276837684768576867687768876897690769176927693769476957696769776987699770077017702770377047705770677077708770977107711771277137714771577167717771877197720772177227723772477257726772777287729773077317732773377347735773677377738773977407741774277437744774577467747774877497750775177527753775477557756775777587759776077617762776377647765776677677768776977707771777277737774777577767777777877797780778177827783778477857786778777887789779077917792779377947795779677977798779978007801780278037804780578067807780878097810781178127813781478157816781778187819782078217822782378247825782678277828782978307831783278337834783578367837783878397840784178427843784478457846784778487849785078517852785378547855785678577858785978607861786278637864786578667867786878697870787178727873787478757876787778787879788078817882788378847885788678877888788978907891789278937894789578967897789878997900790179027903790479057906790779087909791079117912791379147915791679177918791979207921792279237924792579267927792879297930793179327933793479357936793779387939794079417942794379447945794679477948794979507951795279537954795579567957795879597960796179627963796479657966796779687969797079717972797379747975797679777978797979807981798279837984798579867987798879897990799179927993799479957996799779987999800080018002800380048005800680078008800980108011801280138014801580168017801880198020802180228023802480258026802780288029803080318032803380348035803680378038803980408041804280438044804580468047804880498050805180528053805480558056805780588059806080618062806380648065806680678068806980708071807280738074807580768077807880798080808180828083808480858086808780888089
  1. /*
  2. * kernel/sched/core.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 <asm/mmu_context.h>
  35. #include <linux/interrupt.h>
  36. #include <linux/capability.h>
  37. #include <linux/completion.h>
  38. #include <linux/kernel_stat.h>
  39. #include <linux/debug_locks.h>
  40. #include <linux/perf_event.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/proc_fs.h>
  57. #include <linux/seq_file.h>
  58. #include <linux/sysctl.h>
  59. #include <linux/syscalls.h>
  60. #include <linux/times.h>
  61. #include <linux/tsacct_kern.h>
  62. #include <linux/kprobes.h>
  63. #include <linux/delayacct.h>
  64. #include <linux/unistd.h>
  65. #include <linux/pagemap.h>
  66. #include <linux/hrtimer.h>
  67. #include <linux/tick.h>
  68. #include <linux/debugfs.h>
  69. #include <linux/ctype.h>
  70. #include <linux/ftrace.h>
  71. #include <linux/slab.h>
  72. #include <linux/init_task.h>
  73. #include <linux/binfmts.h>
  74. #include <linux/context_tracking.h>
  75. #include <asm/switch_to.h>
  76. #include <asm/tlb.h>
  77. #include <asm/irq_regs.h>
  78. #include <asm/mutex.h>
  79. #ifdef CONFIG_PARAVIRT
  80. #include <asm/paravirt.h>
  81. #endif
  82. #include "sched.h"
  83. #include "../workqueue_sched.h"
  84. #include "../smpboot.h"
  85. #define CREATE_TRACE_POINTS
  86. #include <trace/events/sched.h>
  87. void start_bandwidth_timer(struct hrtimer *period_timer, ktime_t period)
  88. {
  89. unsigned long delta;
  90. ktime_t soft, hard, now;
  91. for (;;) {
  92. if (hrtimer_active(period_timer))
  93. break;
  94. now = hrtimer_cb_get_time(period_timer);
  95. hrtimer_forward(period_timer, now, period);
  96. soft = hrtimer_get_softexpires(period_timer);
  97. hard = hrtimer_get_expires(period_timer);
  98. delta = ktime_to_ns(ktime_sub(hard, soft));
  99. __hrtimer_start_range_ns(period_timer, soft, delta,
  100. HRTIMER_MODE_ABS_PINNED, 0);
  101. }
  102. }
  103. DEFINE_MUTEX(sched_domains_mutex);
  104. DEFINE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues);
  105. static void update_rq_clock_task(struct rq *rq, s64 delta);
  106. void update_rq_clock(struct rq *rq)
  107. {
  108. s64 delta;
  109. if (rq->skip_clock_update > 0)
  110. return;
  111. delta = sched_clock_cpu(cpu_of(rq)) - rq->clock;
  112. rq->clock += delta;
  113. update_rq_clock_task(rq, delta);
  114. }
  115. /*
  116. * Debugging: various feature bits
  117. */
  118. #define SCHED_FEAT(name, enabled) \
  119. (1UL << __SCHED_FEAT_##name) * enabled |
  120. const_debug unsigned int sysctl_sched_features =
  121. #include "features.h"
  122. 0;
  123. #undef SCHED_FEAT
  124. #ifdef CONFIG_SCHED_DEBUG
  125. #define SCHED_FEAT(name, enabled) \
  126. #name ,
  127. static const char * const sched_feat_names[] = {
  128. #include "features.h"
  129. };
  130. #undef SCHED_FEAT
  131. static int sched_feat_show(struct seq_file *m, void *v)
  132. {
  133. int i;
  134. for (i = 0; i < __SCHED_FEAT_NR; i++) {
  135. if (!(sysctl_sched_features & (1UL << i)))
  136. seq_puts(m, "NO_");
  137. seq_printf(m, "%s ", sched_feat_names[i]);
  138. }
  139. seq_puts(m, "\n");
  140. return 0;
  141. }
  142. #ifdef HAVE_JUMP_LABEL
  143. #define jump_label_key__true STATIC_KEY_INIT_TRUE
  144. #define jump_label_key__false STATIC_KEY_INIT_FALSE
  145. #define SCHED_FEAT(name, enabled) \
  146. jump_label_key__##enabled ,
  147. struct static_key sched_feat_keys[__SCHED_FEAT_NR] = {
  148. #include "features.h"
  149. };
  150. #undef SCHED_FEAT
  151. static void sched_feat_disable(int i)
  152. {
  153. if (static_key_enabled(&sched_feat_keys[i]))
  154. static_key_slow_dec(&sched_feat_keys[i]);
  155. }
  156. static void sched_feat_enable(int i)
  157. {
  158. if (!static_key_enabled(&sched_feat_keys[i]))
  159. static_key_slow_inc(&sched_feat_keys[i]);
  160. }
  161. #else
  162. static void sched_feat_disable(int i) { };
  163. static void sched_feat_enable(int i) { };
  164. #endif /* HAVE_JUMP_LABEL */
  165. static ssize_t
  166. sched_feat_write(struct file *filp, const char __user *ubuf,
  167. size_t cnt, loff_t *ppos)
  168. {
  169. char buf[64];
  170. char *cmp;
  171. int neg = 0;
  172. int i;
  173. if (cnt > 63)
  174. cnt = 63;
  175. if (copy_from_user(&buf, ubuf, cnt))
  176. return -EFAULT;
  177. buf[cnt] = 0;
  178. cmp = strstrip(buf);
  179. if (strncmp(cmp, "NO_", 3) == 0) {
  180. neg = 1;
  181. cmp += 3;
  182. }
  183. for (i = 0; i < __SCHED_FEAT_NR; i++) {
  184. if (strcmp(cmp, sched_feat_names[i]) == 0) {
  185. if (neg) {
  186. sysctl_sched_features &= ~(1UL << i);
  187. sched_feat_disable(i);
  188. } else {
  189. sysctl_sched_features |= (1UL << i);
  190. sched_feat_enable(i);
  191. }
  192. break;
  193. }
  194. }
  195. if (i == __SCHED_FEAT_NR)
  196. return -EINVAL;
  197. *ppos += cnt;
  198. return cnt;
  199. }
  200. static int sched_feat_open(struct inode *inode, struct file *filp)
  201. {
  202. return single_open(filp, sched_feat_show, NULL);
  203. }
  204. static const struct file_operations sched_feat_fops = {
  205. .open = sched_feat_open,
  206. .write = sched_feat_write,
  207. .read = seq_read,
  208. .llseek = seq_lseek,
  209. .release = single_release,
  210. };
  211. static __init int sched_init_debug(void)
  212. {
  213. debugfs_create_file("sched_features", 0644, NULL, NULL,
  214. &sched_feat_fops);
  215. return 0;
  216. }
  217. late_initcall(sched_init_debug);
  218. #endif /* CONFIG_SCHED_DEBUG */
  219. /*
  220. * Number of tasks to iterate in a single balance run.
  221. * Limited because this is done with IRQs disabled.
  222. */
  223. const_debug unsigned int sysctl_sched_nr_migrate = 32;
  224. /*
  225. * period over which we average the RT time consumption, measured
  226. * in ms.
  227. *
  228. * default: 1s
  229. */
  230. const_debug unsigned int sysctl_sched_time_avg = MSEC_PER_SEC;
  231. /*
  232. * period over which we measure -rt task cpu usage in us.
  233. * default: 1s
  234. */
  235. unsigned int sysctl_sched_rt_period = 1000000;
  236. __read_mostly int scheduler_running;
  237. /*
  238. * part of the period that we allow rt tasks to run in us.
  239. * default: 0.95s
  240. */
  241. int sysctl_sched_rt_runtime = 950000;
  242. /*
  243. * __task_rq_lock - lock the rq @p resides on.
  244. */
  245. static inline struct rq *__task_rq_lock(struct task_struct *p)
  246. __acquires(rq->lock)
  247. {
  248. struct rq *rq;
  249. lockdep_assert_held(&p->pi_lock);
  250. for (;;) {
  251. rq = task_rq(p);
  252. raw_spin_lock(&rq->lock);
  253. if (likely(rq == task_rq(p)))
  254. return rq;
  255. raw_spin_unlock(&rq->lock);
  256. }
  257. }
  258. /*
  259. * task_rq_lock - lock p->pi_lock and lock the rq @p resides on.
  260. */
  261. static struct rq *task_rq_lock(struct task_struct *p, unsigned long *flags)
  262. __acquires(p->pi_lock)
  263. __acquires(rq->lock)
  264. {
  265. struct rq *rq;
  266. for (;;) {
  267. raw_spin_lock_irqsave(&p->pi_lock, *flags);
  268. rq = task_rq(p);
  269. raw_spin_lock(&rq->lock);
  270. if (likely(rq == task_rq(p)))
  271. return rq;
  272. raw_spin_unlock(&rq->lock);
  273. raw_spin_unlock_irqrestore(&p->pi_lock, *flags);
  274. }
  275. }
  276. static void __task_rq_unlock(struct rq *rq)
  277. __releases(rq->lock)
  278. {
  279. raw_spin_unlock(&rq->lock);
  280. }
  281. static inline void
  282. task_rq_unlock(struct rq *rq, struct task_struct *p, unsigned long *flags)
  283. __releases(rq->lock)
  284. __releases(p->pi_lock)
  285. {
  286. raw_spin_unlock(&rq->lock);
  287. raw_spin_unlock_irqrestore(&p->pi_lock, *flags);
  288. }
  289. /*
  290. * this_rq_lock - lock this runqueue and disable interrupts.
  291. */
  292. static struct rq *this_rq_lock(void)
  293. __acquires(rq->lock)
  294. {
  295. struct rq *rq;
  296. local_irq_disable();
  297. rq = this_rq();
  298. raw_spin_lock(&rq->lock);
  299. return rq;
  300. }
  301. #ifdef CONFIG_SCHED_HRTICK
  302. /*
  303. * Use HR-timers to deliver accurate preemption points.
  304. *
  305. * Its all a bit involved since we cannot program an hrt while holding the
  306. * rq->lock. So what we do is store a state in in rq->hrtick_* and ask for a
  307. * reschedule event.
  308. *
  309. * When we get rescheduled we reprogram the hrtick_timer outside of the
  310. * rq->lock.
  311. */
  312. static void hrtick_clear(struct rq *rq)
  313. {
  314. if (hrtimer_active(&rq->hrtick_timer))
  315. hrtimer_cancel(&rq->hrtick_timer);
  316. }
  317. /*
  318. * High-resolution timer tick.
  319. * Runs from hardirq context with interrupts disabled.
  320. */
  321. static enum hrtimer_restart hrtick(struct hrtimer *timer)
  322. {
  323. struct rq *rq = container_of(timer, struct rq, hrtick_timer);
  324. WARN_ON_ONCE(cpu_of(rq) != smp_processor_id());
  325. raw_spin_lock(&rq->lock);
  326. update_rq_clock(rq);
  327. rq->curr->sched_class->task_tick(rq, rq->curr, 1);
  328. raw_spin_unlock(&rq->lock);
  329. return HRTIMER_NORESTART;
  330. }
  331. #ifdef CONFIG_SMP
  332. /*
  333. * called from hardirq (IPI) context
  334. */
  335. static void __hrtick_start(void *arg)
  336. {
  337. struct rq *rq = arg;
  338. raw_spin_lock(&rq->lock);
  339. hrtimer_restart(&rq->hrtick_timer);
  340. rq->hrtick_csd_pending = 0;
  341. raw_spin_unlock(&rq->lock);
  342. }
  343. /*
  344. * Called to set the hrtick timer state.
  345. *
  346. * called with rq->lock held and irqs disabled
  347. */
  348. void hrtick_start(struct rq *rq, u64 delay)
  349. {
  350. struct hrtimer *timer = &rq->hrtick_timer;
  351. ktime_t time = ktime_add_ns(timer->base->get_time(), delay);
  352. hrtimer_set_expires(timer, time);
  353. if (rq == this_rq()) {
  354. hrtimer_restart(timer);
  355. } else if (!rq->hrtick_csd_pending) {
  356. __smp_call_function_single(cpu_of(rq), &rq->hrtick_csd, 0);
  357. rq->hrtick_csd_pending = 1;
  358. }
  359. }
  360. static int
  361. hotplug_hrtick(struct notifier_block *nfb, unsigned long action, void *hcpu)
  362. {
  363. int cpu = (int)(long)hcpu;
  364. switch (action) {
  365. case CPU_UP_CANCELED:
  366. case CPU_UP_CANCELED_FROZEN:
  367. case CPU_DOWN_PREPARE:
  368. case CPU_DOWN_PREPARE_FROZEN:
  369. case CPU_DEAD:
  370. case CPU_DEAD_FROZEN:
  371. hrtick_clear(cpu_rq(cpu));
  372. return NOTIFY_OK;
  373. }
  374. return NOTIFY_DONE;
  375. }
  376. static __init void init_hrtick(void)
  377. {
  378. hotcpu_notifier(hotplug_hrtick, 0);
  379. }
  380. #else
  381. /*
  382. * Called to set the hrtick timer state.
  383. *
  384. * called with rq->lock held and irqs disabled
  385. */
  386. void hrtick_start(struct rq *rq, u64 delay)
  387. {
  388. __hrtimer_start_range_ns(&rq->hrtick_timer, ns_to_ktime(delay), 0,
  389. HRTIMER_MODE_REL_PINNED, 0);
  390. }
  391. static inline void init_hrtick(void)
  392. {
  393. }
  394. #endif /* CONFIG_SMP */
  395. static void init_rq_hrtick(struct rq *rq)
  396. {
  397. #ifdef CONFIG_SMP
  398. rq->hrtick_csd_pending = 0;
  399. rq->hrtick_csd.flags = 0;
  400. rq->hrtick_csd.func = __hrtick_start;
  401. rq->hrtick_csd.info = rq;
  402. #endif
  403. hrtimer_init(&rq->hrtick_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
  404. rq->hrtick_timer.function = hrtick;
  405. }
  406. #else /* CONFIG_SCHED_HRTICK */
  407. static inline void hrtick_clear(struct rq *rq)
  408. {
  409. }
  410. static inline void init_rq_hrtick(struct rq *rq)
  411. {
  412. }
  413. static inline void init_hrtick(void)
  414. {
  415. }
  416. #endif /* CONFIG_SCHED_HRTICK */
  417. /*
  418. * resched_task - mark a task 'to be rescheduled now'.
  419. *
  420. * On UP this means the setting of the need_resched flag, on SMP it
  421. * might also involve a cross-CPU call to trigger the scheduler on
  422. * the target CPU.
  423. */
  424. #ifdef CONFIG_SMP
  425. #ifndef tsk_is_polling
  426. #define tsk_is_polling(t) 0
  427. #endif
  428. void resched_task(struct task_struct *p)
  429. {
  430. int cpu;
  431. assert_raw_spin_locked(&task_rq(p)->lock);
  432. if (test_tsk_need_resched(p))
  433. return;
  434. set_tsk_need_resched(p);
  435. cpu = task_cpu(p);
  436. if (cpu == smp_processor_id())
  437. return;
  438. /* NEED_RESCHED must be visible before we test polling */
  439. smp_mb();
  440. if (!tsk_is_polling(p))
  441. smp_send_reschedule(cpu);
  442. }
  443. void resched_cpu(int cpu)
  444. {
  445. struct rq *rq = cpu_rq(cpu);
  446. unsigned long flags;
  447. if (!raw_spin_trylock_irqsave(&rq->lock, flags))
  448. return;
  449. resched_task(cpu_curr(cpu));
  450. raw_spin_unlock_irqrestore(&rq->lock, flags);
  451. }
  452. #ifdef CONFIG_NO_HZ
  453. /*
  454. * In the semi idle case, use the nearest busy cpu for migrating timers
  455. * from an idle cpu. This is good for power-savings.
  456. *
  457. * We don't do similar optimization for completely idle system, as
  458. * selecting an idle cpu will add more delays to the timers than intended
  459. * (as that cpu's timer base may not be uptodate wrt jiffies etc).
  460. */
  461. int get_nohz_timer_target(void)
  462. {
  463. int cpu = smp_processor_id();
  464. int i;
  465. struct sched_domain *sd;
  466. rcu_read_lock();
  467. for_each_domain(cpu, sd) {
  468. for_each_cpu(i, sched_domain_span(sd)) {
  469. if (!idle_cpu(i)) {
  470. cpu = i;
  471. goto unlock;
  472. }
  473. }
  474. }
  475. unlock:
  476. rcu_read_unlock();
  477. return cpu;
  478. }
  479. /*
  480. * When add_timer_on() enqueues a timer into the timer wheel of an
  481. * idle CPU then this timer might expire before the next timer event
  482. * which is scheduled to wake up that CPU. In case of a completely
  483. * idle system the next event might even be infinite time into the
  484. * future. wake_up_idle_cpu() ensures that the CPU is woken up and
  485. * leaves the inner idle loop so the newly added timer is taken into
  486. * account when the CPU goes back to idle and evaluates the timer
  487. * wheel for the next timer event.
  488. */
  489. void wake_up_idle_cpu(int cpu)
  490. {
  491. struct rq *rq = cpu_rq(cpu);
  492. if (cpu == smp_processor_id())
  493. return;
  494. /*
  495. * This is safe, as this function is called with the timer
  496. * wheel base lock of (cpu) held. When the CPU is on the way
  497. * to idle and has not yet set rq->curr to idle then it will
  498. * be serialized on the timer wheel base lock and take the new
  499. * timer into account automatically.
  500. */
  501. if (rq->curr != rq->idle)
  502. return;
  503. /*
  504. * We can set TIF_RESCHED on the idle task of the other CPU
  505. * lockless. The worst case is that the other CPU runs the
  506. * idle task through an additional NOOP schedule()
  507. */
  508. set_tsk_need_resched(rq->idle);
  509. /* NEED_RESCHED must be visible before we test polling */
  510. smp_mb();
  511. if (!tsk_is_polling(rq->idle))
  512. smp_send_reschedule(cpu);
  513. }
  514. static inline bool got_nohz_idle_kick(void)
  515. {
  516. int cpu = smp_processor_id();
  517. return idle_cpu(cpu) && test_bit(NOHZ_BALANCE_KICK, nohz_flags(cpu));
  518. }
  519. #else /* CONFIG_NO_HZ */
  520. static inline bool got_nohz_idle_kick(void)
  521. {
  522. return false;
  523. }
  524. #endif /* CONFIG_NO_HZ */
  525. void sched_avg_update(struct rq *rq)
  526. {
  527. s64 period = sched_avg_period();
  528. while ((s64)(rq->clock - rq->age_stamp) > period) {
  529. /*
  530. * Inline assembly required to prevent the compiler
  531. * optimising this loop into a divmod call.
  532. * See __iter_div_u64_rem() for another example of this.
  533. */
  534. asm("" : "+rm" (rq->age_stamp));
  535. rq->age_stamp += period;
  536. rq->rt_avg /= 2;
  537. }
  538. }
  539. #else /* !CONFIG_SMP */
  540. void resched_task(struct task_struct *p)
  541. {
  542. assert_raw_spin_locked(&task_rq(p)->lock);
  543. set_tsk_need_resched(p);
  544. }
  545. #endif /* CONFIG_SMP */
  546. #if defined(CONFIG_RT_GROUP_SCHED) || (defined(CONFIG_FAIR_GROUP_SCHED) && \
  547. (defined(CONFIG_SMP) || defined(CONFIG_CFS_BANDWIDTH)))
  548. /*
  549. * Iterate task_group tree rooted at *from, calling @down when first entering a
  550. * node and @up when leaving it for the final time.
  551. *
  552. * Caller must hold rcu_lock or sufficient equivalent.
  553. */
  554. int walk_tg_tree_from(struct task_group *from,
  555. tg_visitor down, tg_visitor up, void *data)
  556. {
  557. struct task_group *parent, *child;
  558. int ret;
  559. parent = from;
  560. down:
  561. ret = (*down)(parent, data);
  562. if (ret)
  563. goto out;
  564. list_for_each_entry_rcu(child, &parent->children, siblings) {
  565. parent = child;
  566. goto down;
  567. up:
  568. continue;
  569. }
  570. ret = (*up)(parent, data);
  571. if (ret || parent == from)
  572. goto out;
  573. child = parent;
  574. parent = parent->parent;
  575. if (parent)
  576. goto up;
  577. out:
  578. return ret;
  579. }
  580. int tg_nop(struct task_group *tg, void *data)
  581. {
  582. return 0;
  583. }
  584. #endif
  585. static void set_load_weight(struct task_struct *p)
  586. {
  587. int prio = p->static_prio - MAX_RT_PRIO;
  588. struct load_weight *load = &p->se.load;
  589. /*
  590. * SCHED_IDLE tasks get minimal weight:
  591. */
  592. if (p->policy == SCHED_IDLE) {
  593. load->weight = scale_load(WEIGHT_IDLEPRIO);
  594. load->inv_weight = WMULT_IDLEPRIO;
  595. return;
  596. }
  597. load->weight = scale_load(prio_to_weight[prio]);
  598. load->inv_weight = prio_to_wmult[prio];
  599. }
  600. static void enqueue_task(struct rq *rq, struct task_struct *p, int flags)
  601. {
  602. update_rq_clock(rq);
  603. sched_info_queued(p);
  604. p->sched_class->enqueue_task(rq, p, flags);
  605. }
  606. static void dequeue_task(struct rq *rq, struct task_struct *p, int flags)
  607. {
  608. update_rq_clock(rq);
  609. sched_info_dequeued(p);
  610. p->sched_class->dequeue_task(rq, p, flags);
  611. }
  612. void activate_task(struct rq *rq, struct task_struct *p, int flags)
  613. {
  614. if (task_contributes_to_load(p))
  615. rq->nr_uninterruptible--;
  616. enqueue_task(rq, p, flags);
  617. }
  618. void deactivate_task(struct rq *rq, struct task_struct *p, int flags)
  619. {
  620. if (task_contributes_to_load(p))
  621. rq->nr_uninterruptible++;
  622. dequeue_task(rq, p, flags);
  623. }
  624. static void update_rq_clock_task(struct rq *rq, s64 delta)
  625. {
  626. /*
  627. * In theory, the compile should just see 0 here, and optimize out the call
  628. * to sched_rt_avg_update. But I don't trust it...
  629. */
  630. #if defined(CONFIG_IRQ_TIME_ACCOUNTING) || defined(CONFIG_PARAVIRT_TIME_ACCOUNTING)
  631. s64 steal = 0, irq_delta = 0;
  632. #endif
  633. #ifdef CONFIG_IRQ_TIME_ACCOUNTING
  634. irq_delta = irq_time_read(cpu_of(rq)) - rq->prev_irq_time;
  635. /*
  636. * Since irq_time is only updated on {soft,}irq_exit, we might run into
  637. * this case when a previous update_rq_clock() happened inside a
  638. * {soft,}irq region.
  639. *
  640. * When this happens, we stop ->clock_task and only update the
  641. * prev_irq_time stamp to account for the part that fit, so that a next
  642. * update will consume the rest. This ensures ->clock_task is
  643. * monotonic.
  644. *
  645. * It does however cause some slight miss-attribution of {soft,}irq
  646. * time, a more accurate solution would be to update the irq_time using
  647. * the current rq->clock timestamp, except that would require using
  648. * atomic ops.
  649. */
  650. if (irq_delta > delta)
  651. irq_delta = delta;
  652. rq->prev_irq_time += irq_delta;
  653. delta -= irq_delta;
  654. #endif
  655. #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING
  656. if (static_key_false((&paravirt_steal_rq_enabled))) {
  657. u64 st;
  658. steal = paravirt_steal_clock(cpu_of(rq));
  659. steal -= rq->prev_steal_time_rq;
  660. if (unlikely(steal > delta))
  661. steal = delta;
  662. st = steal_ticks(steal);
  663. steal = st * TICK_NSEC;
  664. rq->prev_steal_time_rq += steal;
  665. delta -= steal;
  666. }
  667. #endif
  668. rq->clock_task += delta;
  669. #if defined(CONFIG_IRQ_TIME_ACCOUNTING) || defined(CONFIG_PARAVIRT_TIME_ACCOUNTING)
  670. if ((irq_delta + steal) && sched_feat(NONTASK_POWER))
  671. sched_rt_avg_update(rq, irq_delta + steal);
  672. #endif
  673. }
  674. void sched_set_stop_task(int cpu, struct task_struct *stop)
  675. {
  676. struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
  677. struct task_struct *old_stop = cpu_rq(cpu)->stop;
  678. if (stop) {
  679. /*
  680. * Make it appear like a SCHED_FIFO task, its something
  681. * userspace knows about and won't get confused about.
  682. *
  683. * Also, it will make PI more or less work without too
  684. * much confusion -- but then, stop work should not
  685. * rely on PI working anyway.
  686. */
  687. sched_setscheduler_nocheck(stop, SCHED_FIFO, &param);
  688. stop->sched_class = &stop_sched_class;
  689. }
  690. cpu_rq(cpu)->stop = stop;
  691. if (old_stop) {
  692. /*
  693. * Reset it back to a normal scheduling class so that
  694. * it can die in pieces.
  695. */
  696. old_stop->sched_class = &rt_sched_class;
  697. }
  698. }
  699. /*
  700. * __normal_prio - return the priority that is based on the static prio
  701. */
  702. static inline int __normal_prio(struct task_struct *p)
  703. {
  704. return p->static_prio;
  705. }
  706. /*
  707. * Calculate the expected normal priority: i.e. priority
  708. * without taking RT-inheritance into account. Might be
  709. * boosted by interactivity modifiers. Changes upon fork,
  710. * setprio syscalls, and whenever the interactivity
  711. * estimator recalculates.
  712. */
  713. static inline int normal_prio(struct task_struct *p)
  714. {
  715. int prio;
  716. if (task_has_rt_policy(p))
  717. prio = MAX_RT_PRIO-1 - p->rt_priority;
  718. else
  719. prio = __normal_prio(p);
  720. return prio;
  721. }
  722. /*
  723. * Calculate the current priority, i.e. the priority
  724. * taken into account by the scheduler. This value might
  725. * be boosted by RT tasks, or might be boosted by
  726. * interactivity modifiers. Will be RT if the task got
  727. * RT-boosted. If not then it returns p->normal_prio.
  728. */
  729. static int effective_prio(struct task_struct *p)
  730. {
  731. p->normal_prio = normal_prio(p);
  732. /*
  733. * If we are RT tasks or we were boosted to RT priority,
  734. * keep the priority unchanged. Otherwise, update priority
  735. * to the normal priority:
  736. */
  737. if (!rt_prio(p->prio))
  738. return p->normal_prio;
  739. return p->prio;
  740. }
  741. /**
  742. * task_curr - is this task currently executing on a CPU?
  743. * @p: the task in question.
  744. */
  745. inline int task_curr(const struct task_struct *p)
  746. {
  747. return cpu_curr(task_cpu(p)) == p;
  748. }
  749. static inline void check_class_changed(struct rq *rq, struct task_struct *p,
  750. const struct sched_class *prev_class,
  751. int oldprio)
  752. {
  753. if (prev_class != p->sched_class) {
  754. if (prev_class->switched_from)
  755. prev_class->switched_from(rq, p);
  756. p->sched_class->switched_to(rq, p);
  757. } else if (oldprio != p->prio)
  758. p->sched_class->prio_changed(rq, p, oldprio);
  759. }
  760. void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags)
  761. {
  762. const struct sched_class *class;
  763. if (p->sched_class == rq->curr->sched_class) {
  764. rq->curr->sched_class->check_preempt_curr(rq, p, flags);
  765. } else {
  766. for_each_class(class) {
  767. if (class == rq->curr->sched_class)
  768. break;
  769. if (class == p->sched_class) {
  770. resched_task(rq->curr);
  771. break;
  772. }
  773. }
  774. }
  775. /*
  776. * A queue event has occurred, and we're going to schedule. In
  777. * this case, we can save a useless back to back clock update.
  778. */
  779. if (rq->curr->on_rq && test_tsk_need_resched(rq->curr))
  780. rq->skip_clock_update = 1;
  781. }
  782. #ifdef CONFIG_SMP
  783. void set_task_cpu(struct task_struct *p, unsigned int new_cpu)
  784. {
  785. #ifdef CONFIG_SCHED_DEBUG
  786. /*
  787. * We should never call set_task_cpu() on a blocked task,
  788. * ttwu() will sort out the placement.
  789. */
  790. WARN_ON_ONCE(p->state != TASK_RUNNING && p->state != TASK_WAKING &&
  791. !(task_thread_info(p)->preempt_count & PREEMPT_ACTIVE));
  792. #ifdef CONFIG_LOCKDEP
  793. /*
  794. * The caller should hold either p->pi_lock or rq->lock, when changing
  795. * a task's CPU. ->pi_lock for waking tasks, rq->lock for runnable tasks.
  796. *
  797. * sched_move_task() holds both and thus holding either pins the cgroup,
  798. * see task_group().
  799. *
  800. * Furthermore, all task_rq users should acquire both locks, see
  801. * task_rq_lock().
  802. */
  803. WARN_ON_ONCE(debug_locks && !(lockdep_is_held(&p->pi_lock) ||
  804. lockdep_is_held(&task_rq(p)->lock)));
  805. #endif
  806. #endif
  807. trace_sched_migrate_task(p, new_cpu);
  808. if (task_cpu(p) != new_cpu) {
  809. p->se.nr_migrations++;
  810. perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS, 1, NULL, 0);
  811. }
  812. __set_task_cpu(p, new_cpu);
  813. }
  814. struct migration_arg {
  815. struct task_struct *task;
  816. int dest_cpu;
  817. };
  818. static int migration_cpu_stop(void *data);
  819. /*
  820. * wait_task_inactive - wait for a thread to unschedule.
  821. *
  822. * If @match_state is nonzero, it's the @p->state value just checked and
  823. * not expected to change. If it changes, i.e. @p might have woken up,
  824. * then return zero. When we succeed in waiting for @p to be off its CPU,
  825. * we return a positive number (its total switch count). If a second call
  826. * a short while later returns the same number, the caller can be sure that
  827. * @p has remained unscheduled the whole time.
  828. *
  829. * The caller must ensure that the task *will* unschedule sometime soon,
  830. * else this function might spin for a *long* time. This function can't
  831. * be called with interrupts off, or it may introduce deadlock with
  832. * smp_call_function() if an IPI is sent by the same process we are
  833. * waiting to become inactive.
  834. */
  835. unsigned long wait_task_inactive(struct task_struct *p, long match_state)
  836. {
  837. unsigned long flags;
  838. int running, on_rq;
  839. unsigned long ncsw;
  840. struct rq *rq;
  841. for (;;) {
  842. /*
  843. * We do the initial early heuristics without holding
  844. * any task-queue locks at all. We'll only try to get
  845. * the runqueue lock when things look like they will
  846. * work out!
  847. */
  848. rq = task_rq(p);
  849. /*
  850. * If the task is actively running on another CPU
  851. * still, just relax and busy-wait without holding
  852. * any locks.
  853. *
  854. * NOTE! Since we don't hold any locks, it's not
  855. * even sure that "rq" stays as the right runqueue!
  856. * But we don't care, since "task_running()" will
  857. * return false if the runqueue has changed and p
  858. * is actually now running somewhere else!
  859. */
  860. while (task_running(rq, p)) {
  861. if (match_state && unlikely(p->state != match_state))
  862. return 0;
  863. cpu_relax();
  864. }
  865. /*
  866. * Ok, time to look more closely! We need the rq
  867. * lock now, to be *sure*. If we're wrong, we'll
  868. * just go back and repeat.
  869. */
  870. rq = task_rq_lock(p, &flags);
  871. trace_sched_wait_task(p);
  872. running = task_running(rq, p);
  873. on_rq = p->on_rq;
  874. ncsw = 0;
  875. if (!match_state || p->state == match_state)
  876. ncsw = p->nvcsw | LONG_MIN; /* sets MSB */
  877. task_rq_unlock(rq, p, &flags);
  878. /*
  879. * If it changed from the expected state, bail out now.
  880. */
  881. if (unlikely(!ncsw))
  882. break;
  883. /*
  884. * Was it really running after all now that we
  885. * checked with the proper locks actually held?
  886. *
  887. * Oops. Go back and try again..
  888. */
  889. if (unlikely(running)) {
  890. cpu_relax();
  891. continue;
  892. }
  893. /*
  894. * It's not enough that it's not actively running,
  895. * it must be off the runqueue _entirely_, and not
  896. * preempted!
  897. *
  898. * So if it was still runnable (but just not actively
  899. * running right now), it's preempted, and we should
  900. * yield - it could be a while.
  901. */
  902. if (unlikely(on_rq)) {
  903. ktime_t to = ktime_set(0, NSEC_PER_SEC/HZ);
  904. set_current_state(TASK_UNINTERRUPTIBLE);
  905. schedule_hrtimeout(&to, HRTIMER_MODE_REL);
  906. continue;
  907. }
  908. /*
  909. * Ahh, all good. It wasn't running, and it wasn't
  910. * runnable, which means that it will never become
  911. * running in the future either. We're all done!
  912. */
  913. break;
  914. }
  915. return ncsw;
  916. }
  917. /***
  918. * kick_process - kick a running thread to enter/exit the kernel
  919. * @p: the to-be-kicked thread
  920. *
  921. * Cause a process which is running on another CPU to enter
  922. * kernel-mode, without any delay. (to get signals handled.)
  923. *
  924. * NOTE: this function doesn't have to take the runqueue lock,
  925. * because all it wants to ensure is that the remote task enters
  926. * the kernel. If the IPI races and the task has been migrated
  927. * to another CPU then no harm is done and the purpose has been
  928. * achieved as well.
  929. */
  930. void kick_process(struct task_struct *p)
  931. {
  932. int cpu;
  933. preempt_disable();
  934. cpu = task_cpu(p);
  935. if ((cpu != smp_processor_id()) && task_curr(p))
  936. smp_send_reschedule(cpu);
  937. preempt_enable();
  938. }
  939. EXPORT_SYMBOL_GPL(kick_process);
  940. #endif /* CONFIG_SMP */
  941. #ifdef CONFIG_SMP
  942. /*
  943. * ->cpus_allowed is protected by both rq->lock and p->pi_lock
  944. */
  945. static int select_fallback_rq(int cpu, struct task_struct *p)
  946. {
  947. const struct cpumask *nodemask = cpumask_of_node(cpu_to_node(cpu));
  948. enum { cpuset, possible, fail } state = cpuset;
  949. int dest_cpu;
  950. /* Look for allowed, online CPU in same node. */
  951. for_each_cpu(dest_cpu, nodemask) {
  952. if (!cpu_online(dest_cpu))
  953. continue;
  954. if (!cpu_active(dest_cpu))
  955. continue;
  956. if (cpumask_test_cpu(dest_cpu, tsk_cpus_allowed(p)))
  957. return dest_cpu;
  958. }
  959. for (;;) {
  960. /* Any allowed, online CPU? */
  961. for_each_cpu(dest_cpu, tsk_cpus_allowed(p)) {
  962. if (!cpu_online(dest_cpu))
  963. continue;
  964. if (!cpu_active(dest_cpu))
  965. continue;
  966. goto out;
  967. }
  968. switch (state) {
  969. case cpuset:
  970. /* No more Mr. Nice Guy. */
  971. cpuset_cpus_allowed_fallback(p);
  972. state = possible;
  973. break;
  974. case possible:
  975. do_set_cpus_allowed(p, cpu_possible_mask);
  976. state = fail;
  977. break;
  978. case fail:
  979. BUG();
  980. break;
  981. }
  982. }
  983. out:
  984. if (state != cpuset) {
  985. /*
  986. * Don't tell them about moving exiting tasks or
  987. * kernel threads (both mm NULL), since they never
  988. * leave kernel.
  989. */
  990. if (p->mm && printk_ratelimit()) {
  991. printk_sched("process %d (%s) no longer affine to cpu%d\n",
  992. task_pid_nr(p), p->comm, cpu);
  993. }
  994. }
  995. return dest_cpu;
  996. }
  997. /*
  998. * The caller (fork, wakeup) owns p->pi_lock, ->cpus_allowed is stable.
  999. */
  1000. static inline
  1001. int select_task_rq(struct task_struct *p, int sd_flags, int wake_flags)
  1002. {
  1003. int cpu = p->sched_class->select_task_rq(p, sd_flags, wake_flags);
  1004. /*
  1005. * In order not to call set_task_cpu() on a blocking task we need
  1006. * to rely on ttwu() to place the task on a valid ->cpus_allowed
  1007. * cpu.
  1008. *
  1009. * Since this is common to all placement strategies, this lives here.
  1010. *
  1011. * [ this allows ->select_task() to simply return task_cpu(p) and
  1012. * not worry about this generic constraint ]
  1013. */
  1014. if (unlikely(!cpumask_test_cpu(cpu, tsk_cpus_allowed(p)) ||
  1015. !cpu_online(cpu)))
  1016. cpu = select_fallback_rq(task_cpu(p), p);
  1017. return cpu;
  1018. }
  1019. static void update_avg(u64 *avg, u64 sample)
  1020. {
  1021. s64 diff = sample - *avg;
  1022. *avg += diff >> 3;
  1023. }
  1024. #endif
  1025. static void
  1026. ttwu_stat(struct task_struct *p, int cpu, int wake_flags)
  1027. {
  1028. #ifdef CONFIG_SCHEDSTATS
  1029. struct rq *rq = this_rq();
  1030. #ifdef CONFIG_SMP
  1031. int this_cpu = smp_processor_id();
  1032. if (cpu == this_cpu) {
  1033. schedstat_inc(rq, ttwu_local);
  1034. schedstat_inc(p, se.statistics.nr_wakeups_local);
  1035. } else {
  1036. struct sched_domain *sd;
  1037. schedstat_inc(p, se.statistics.nr_wakeups_remote);
  1038. rcu_read_lock();
  1039. for_each_domain(this_cpu, sd) {
  1040. if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {
  1041. schedstat_inc(sd, ttwu_wake_remote);
  1042. break;
  1043. }
  1044. }
  1045. rcu_read_unlock();
  1046. }
  1047. if (wake_flags & WF_MIGRATED)
  1048. schedstat_inc(p, se.statistics.nr_wakeups_migrate);
  1049. #endif /* CONFIG_SMP */
  1050. schedstat_inc(rq, ttwu_count);
  1051. schedstat_inc(p, se.statistics.nr_wakeups);
  1052. if (wake_flags & WF_SYNC)
  1053. schedstat_inc(p, se.statistics.nr_wakeups_sync);
  1054. #endif /* CONFIG_SCHEDSTATS */
  1055. }
  1056. static void ttwu_activate(struct rq *rq, struct task_struct *p, int en_flags)
  1057. {
  1058. activate_task(rq, p, en_flags);
  1059. p->on_rq = 1;
  1060. /* if a worker is waking up, notify workqueue */
  1061. if (p->flags & PF_WQ_WORKER)
  1062. wq_worker_waking_up(p, cpu_of(rq));
  1063. }
  1064. /*
  1065. * Mark the task runnable and perform wakeup-preemption.
  1066. */
  1067. static void
  1068. ttwu_do_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
  1069. {
  1070. trace_sched_wakeup(p, true);
  1071. check_preempt_curr(rq, p, wake_flags);
  1072. p->state = TASK_RUNNING;
  1073. #ifdef CONFIG_SMP
  1074. if (p->sched_class->task_woken)
  1075. p->sched_class->task_woken(rq, p);
  1076. if (rq->idle_stamp) {
  1077. u64 delta = rq->clock - rq->idle_stamp;
  1078. u64 max = 2*sysctl_sched_migration_cost;
  1079. if (delta > max)
  1080. rq->avg_idle = max;
  1081. else
  1082. update_avg(&rq->avg_idle, delta);
  1083. rq->idle_stamp = 0;
  1084. }
  1085. #endif
  1086. }
  1087. static void
  1088. ttwu_do_activate(struct rq *rq, struct task_struct *p, int wake_flags)
  1089. {
  1090. #ifdef CONFIG_SMP
  1091. if (p->sched_contributes_to_load)
  1092. rq->nr_uninterruptible--;
  1093. #endif
  1094. ttwu_activate(rq, p, ENQUEUE_WAKEUP | ENQUEUE_WAKING);
  1095. ttwu_do_wakeup(rq, p, wake_flags);
  1096. }
  1097. /*
  1098. * Called in case the task @p isn't fully descheduled from its runqueue,
  1099. * in this case we must do a remote wakeup. Its a 'light' wakeup though,
  1100. * since all we need to do is flip p->state to TASK_RUNNING, since
  1101. * the task is still ->on_rq.
  1102. */
  1103. static int ttwu_remote(struct task_struct *p, int wake_flags)
  1104. {
  1105. struct rq *rq;
  1106. int ret = 0;
  1107. rq = __task_rq_lock(p);
  1108. if (p->on_rq) {
  1109. ttwu_do_wakeup(rq, p, wake_flags);
  1110. ret = 1;
  1111. }
  1112. __task_rq_unlock(rq);
  1113. return ret;
  1114. }
  1115. #ifdef CONFIG_SMP
  1116. static void sched_ttwu_pending(void)
  1117. {
  1118. struct rq *rq = this_rq();
  1119. struct llist_node *llist = llist_del_all(&rq->wake_list);
  1120. struct task_struct *p;
  1121. raw_spin_lock(&rq->lock);
  1122. while (llist) {
  1123. p = llist_entry(llist, struct task_struct, wake_entry);
  1124. llist = llist_next(llist);
  1125. ttwu_do_activate(rq, p, 0);
  1126. }
  1127. raw_spin_unlock(&rq->lock);
  1128. }
  1129. void scheduler_ipi(void)
  1130. {
  1131. if (llist_empty(&this_rq()->wake_list) && !got_nohz_idle_kick())
  1132. return;
  1133. /*
  1134. * Not all reschedule IPI handlers call irq_enter/irq_exit, since
  1135. * traditionally all their work was done from the interrupt return
  1136. * path. Now that we actually do some work, we need to make sure
  1137. * we do call them.
  1138. *
  1139. * Some archs already do call them, luckily irq_enter/exit nest
  1140. * properly.
  1141. *
  1142. * Arguably we should visit all archs and update all handlers,
  1143. * however a fair share of IPIs are still resched only so this would
  1144. * somewhat pessimize the simple resched case.
  1145. */
  1146. irq_enter();
  1147. sched_ttwu_pending();
  1148. /*
  1149. * Check if someone kicked us for doing the nohz idle load balance.
  1150. */
  1151. if (unlikely(got_nohz_idle_kick() && !need_resched())) {
  1152. this_rq()->idle_balance = 1;
  1153. raise_softirq_irqoff(SCHED_SOFTIRQ);
  1154. }
  1155. irq_exit();
  1156. }
  1157. static void ttwu_queue_remote(struct task_struct *p, int cpu)
  1158. {
  1159. if (llist_add(&p->wake_entry, &cpu_rq(cpu)->wake_list))
  1160. smp_send_reschedule(cpu);
  1161. }
  1162. bool cpus_share_cache(int this_cpu, int that_cpu)
  1163. {
  1164. return per_cpu(sd_llc_id, this_cpu) == per_cpu(sd_llc_id, that_cpu);
  1165. }
  1166. #endif /* CONFIG_SMP */
  1167. static void ttwu_queue(struct task_struct *p, int cpu)
  1168. {
  1169. struct rq *rq = cpu_rq(cpu);
  1170. #if defined(CONFIG_SMP)
  1171. if (sched_feat(TTWU_QUEUE) && !cpus_share_cache(smp_processor_id(), cpu)) {
  1172. sched_clock_cpu(cpu); /* sync clocks x-cpu */
  1173. ttwu_queue_remote(p, cpu);
  1174. return;
  1175. }
  1176. #endif
  1177. raw_spin_lock(&rq->lock);
  1178. ttwu_do_activate(rq, p, 0);
  1179. raw_spin_unlock(&rq->lock);
  1180. }
  1181. /**
  1182. * try_to_wake_up - wake up a thread
  1183. * @p: the thread to be awakened
  1184. * @state: the mask of task states that can be woken
  1185. * @wake_flags: wake modifier flags (WF_*)
  1186. *
  1187. * Put it on the run-queue if it's not already there. The "current"
  1188. * thread is always on the run-queue (except when the actual
  1189. * re-schedule is in progress), and as such you're allowed to do
  1190. * the simpler "current->state = TASK_RUNNING" to mark yourself
  1191. * runnable without the overhead of this.
  1192. *
  1193. * Returns %true if @p was woken up, %false if it was already running
  1194. * or @state didn't match @p's state.
  1195. */
  1196. static int
  1197. try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
  1198. {
  1199. unsigned long flags;
  1200. int cpu, success = 0;
  1201. smp_wmb();
  1202. raw_spin_lock_irqsave(&p->pi_lock, flags);
  1203. if (!(p->state & state))
  1204. goto out;
  1205. success = 1; /* we're going to change ->state */
  1206. cpu = task_cpu(p);
  1207. if (p->on_rq && ttwu_remote(p, wake_flags))
  1208. goto stat;
  1209. #ifdef CONFIG_SMP
  1210. /*
  1211. * If the owning (remote) cpu is still in the middle of schedule() with
  1212. * this task as prev, wait until its done referencing the task.
  1213. */
  1214. while (p->on_cpu)
  1215. cpu_relax();
  1216. /*
  1217. * Pairs with the smp_wmb() in finish_lock_switch().
  1218. */
  1219. smp_rmb();
  1220. p->sched_contributes_to_load = !!task_contributes_to_load(p);
  1221. p->state = TASK_WAKING;
  1222. if (p->sched_class->task_waking)
  1223. p->sched_class->task_waking(p);
  1224. cpu = select_task_rq(p, SD_BALANCE_WAKE, wake_flags);
  1225. if (task_cpu(p) != cpu) {
  1226. wake_flags |= WF_MIGRATED;
  1227. set_task_cpu(p, cpu);
  1228. }
  1229. #endif /* CONFIG_SMP */
  1230. ttwu_queue(p, cpu);
  1231. stat:
  1232. ttwu_stat(p, cpu, wake_flags);
  1233. out:
  1234. raw_spin_unlock_irqrestore(&p->pi_lock, flags);
  1235. return success;
  1236. }
  1237. /**
  1238. * try_to_wake_up_local - try to wake up a local task with rq lock held
  1239. * @p: the thread to be awakened
  1240. *
  1241. * Put @p on the run-queue if it's not already there. The caller must
  1242. * ensure that this_rq() is locked, @p is bound to this_rq() and not
  1243. * the current task.
  1244. */
  1245. static void try_to_wake_up_local(struct task_struct *p)
  1246. {
  1247. struct rq *rq = task_rq(p);
  1248. BUG_ON(rq != this_rq());
  1249. BUG_ON(p == current);
  1250. lockdep_assert_held(&rq->lock);
  1251. if (!raw_spin_trylock(&p->pi_lock)) {
  1252. raw_spin_unlock(&rq->lock);
  1253. raw_spin_lock(&p->pi_lock);
  1254. raw_spin_lock(&rq->lock);
  1255. }
  1256. if (!(p->state & TASK_NORMAL))
  1257. goto out;
  1258. if (!p->on_rq)
  1259. ttwu_activate(rq, p, ENQUEUE_WAKEUP);
  1260. ttwu_do_wakeup(rq, p, 0);
  1261. ttwu_stat(p, smp_processor_id(), 0);
  1262. out:
  1263. raw_spin_unlock(&p->pi_lock);
  1264. }
  1265. /**
  1266. * wake_up_process - Wake up a specific process
  1267. * @p: The process to be woken up.
  1268. *
  1269. * Attempt to wake up the nominated process and move it to the set of runnable
  1270. * processes. Returns 1 if the process was woken up, 0 if it was already
  1271. * running.
  1272. *
  1273. * It may be assumed that this function implies a write memory barrier before
  1274. * changing the task state if and only if any tasks are woken up.
  1275. */
  1276. int wake_up_process(struct task_struct *p)
  1277. {
  1278. return try_to_wake_up(p, TASK_ALL, 0);
  1279. }
  1280. EXPORT_SYMBOL(wake_up_process);
  1281. int wake_up_state(struct task_struct *p, unsigned int state)
  1282. {
  1283. return try_to_wake_up(p, state, 0);
  1284. }
  1285. /*
  1286. * Perform scheduler related setup for a newly forked process p.
  1287. * p is forked by current.
  1288. *
  1289. * __sched_fork() is basic setup used by init_idle() too:
  1290. */
  1291. static void __sched_fork(struct task_struct *p)
  1292. {
  1293. p->on_rq = 0;
  1294. p->se.on_rq = 0;
  1295. p->se.exec_start = 0;
  1296. p->se.sum_exec_runtime = 0;
  1297. p->se.prev_sum_exec_runtime = 0;
  1298. p->se.nr_migrations = 0;
  1299. p->se.vruntime = 0;
  1300. INIT_LIST_HEAD(&p->se.group_node);
  1301. #ifdef CONFIG_SCHEDSTATS
  1302. memset(&p->se.statistics, 0, sizeof(p->se.statistics));
  1303. #endif
  1304. INIT_LIST_HEAD(&p->rt.run_list);
  1305. #ifdef CONFIG_PREEMPT_NOTIFIERS
  1306. INIT_HLIST_HEAD(&p->preempt_notifiers);
  1307. #endif
  1308. }
  1309. /*
  1310. * fork()/clone()-time setup:
  1311. */
  1312. void sched_fork(struct task_struct *p)
  1313. {
  1314. unsigned long flags;
  1315. int cpu = get_cpu();
  1316. __sched_fork(p);
  1317. /*
  1318. * We mark the process as running here. This guarantees that
  1319. * nobody will actually run it, and a signal or other external
  1320. * event cannot wake it up and insert it on the runqueue either.
  1321. */
  1322. p->state = TASK_RUNNING;
  1323. /*
  1324. * Make sure we do not leak PI boosting priority to the child.
  1325. */
  1326. p->prio = current->normal_prio;
  1327. /*
  1328. * Revert to default priority/policy on fork if requested.
  1329. */
  1330. if (unlikely(p->sched_reset_on_fork)) {
  1331. if (task_has_rt_policy(p)) {
  1332. p->policy = SCHED_NORMAL;
  1333. p->static_prio = NICE_TO_PRIO(0);
  1334. p->rt_priority = 0;
  1335. } else if (PRIO_TO_NICE(p->static_prio) < 0)
  1336. p->static_prio = NICE_TO_PRIO(0);
  1337. p->prio = p->normal_prio = __normal_prio(p);
  1338. set_load_weight(p);
  1339. /*
  1340. * We don't need the reset flag anymore after the fork. It has
  1341. * fulfilled its duty:
  1342. */
  1343. p->sched_reset_on_fork = 0;
  1344. }
  1345. if (!rt_prio(p->prio))
  1346. p->sched_class = &fair_sched_class;
  1347. if (p->sched_class->task_fork)
  1348. p->sched_class->task_fork(p);
  1349. /*
  1350. * The child is not yet in the pid-hash so no cgroup attach races,
  1351. * and the cgroup is pinned to this child due to cgroup_fork()
  1352. * is ran before sched_fork().
  1353. *
  1354. * Silence PROVE_RCU.
  1355. */
  1356. raw_spin_lock_irqsave(&p->pi_lock, flags);
  1357. set_task_cpu(p, cpu);
  1358. raw_spin_unlock_irqrestore(&p->pi_lock, flags);
  1359. #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
  1360. if (likely(sched_info_on()))
  1361. memset(&p->sched_info, 0, sizeof(p->sched_info));
  1362. #endif
  1363. #if defined(CONFIG_SMP)
  1364. p->on_cpu = 0;
  1365. #endif
  1366. #ifdef CONFIG_PREEMPT_COUNT
  1367. /* Want to start with kernel preemption disabled. */
  1368. task_thread_info(p)->preempt_count = 1;
  1369. #endif
  1370. #ifdef CONFIG_SMP
  1371. plist_node_init(&p->pushable_tasks, MAX_PRIO);
  1372. #endif
  1373. put_cpu();
  1374. }
  1375. /*
  1376. * wake_up_new_task - wake up a newly created task for the first time.
  1377. *
  1378. * This function will do some initial scheduler statistics housekeeping
  1379. * that must be done for every newly created context, then puts the task
  1380. * on the runqueue and wakes it.
  1381. */
  1382. void wake_up_new_task(struct task_struct *p)
  1383. {
  1384. unsigned long flags;
  1385. struct rq *rq;
  1386. raw_spin_lock_irqsave(&p->pi_lock, flags);
  1387. #ifdef CONFIG_SMP
  1388. /*
  1389. * Fork balancing, do it here and not earlier because:
  1390. * - cpus_allowed can change in the fork path
  1391. * - any previously selected cpu might disappear through hotplug
  1392. */
  1393. set_task_cpu(p, select_task_rq(p, SD_BALANCE_FORK, 0));
  1394. #endif
  1395. rq = __task_rq_lock(p);
  1396. activate_task(rq, p, 0);
  1397. p->on_rq = 1;
  1398. trace_sched_wakeup_new(p, true);
  1399. check_preempt_curr(rq, p, WF_FORK);
  1400. #ifdef CONFIG_SMP
  1401. if (p->sched_class->task_woken)
  1402. p->sched_class->task_woken(rq, p);
  1403. #endif
  1404. task_rq_unlock(rq, p, &flags);
  1405. }
  1406. #ifdef CONFIG_PREEMPT_NOTIFIERS
  1407. /**
  1408. * preempt_notifier_register - tell me when current is being preempted & rescheduled
  1409. * @notifier: notifier struct to register
  1410. */
  1411. void preempt_notifier_register(struct preempt_notifier *notifier)
  1412. {
  1413. hlist_add_head(&notifier->link, &current->preempt_notifiers);
  1414. }
  1415. EXPORT_SYMBOL_GPL(preempt_notifier_register);
  1416. /**
  1417. * preempt_notifier_unregister - no longer interested in preemption notifications
  1418. * @notifier: notifier struct to unregister
  1419. *
  1420. * This is safe to call from within a preemption notifier.
  1421. */
  1422. void preempt_notifier_unregister(struct preempt_notifier *notifier)
  1423. {
  1424. hlist_del(&notifier->link);
  1425. }
  1426. EXPORT_SYMBOL_GPL(preempt_notifier_unregister);
  1427. static void fire_sched_in_preempt_notifiers(struct task_struct *curr)
  1428. {
  1429. struct preempt_notifier *notifier;
  1430. struct hlist_node *node;
  1431. hlist_for_each_entry(notifier, node, &curr->preempt_notifiers, link)
  1432. notifier->ops->sched_in(notifier, raw_smp_processor_id());
  1433. }
  1434. static void
  1435. fire_sched_out_preempt_notifiers(struct task_struct *curr,
  1436. struct task_struct *next)
  1437. {
  1438. struct preempt_notifier *notifier;
  1439. struct hlist_node *node;
  1440. hlist_for_each_entry(notifier, node, &curr->preempt_notifiers, link)
  1441. notifier->ops->sched_out(notifier, next);
  1442. }
  1443. #else /* !CONFIG_PREEMPT_NOTIFIERS */
  1444. static void fire_sched_in_preempt_notifiers(struct task_struct *curr)
  1445. {
  1446. }
  1447. static void
  1448. fire_sched_out_preempt_notifiers(struct task_struct *curr,
  1449. struct task_struct *next)
  1450. {
  1451. }
  1452. #endif /* CONFIG_PREEMPT_NOTIFIERS */
  1453. /**
  1454. * prepare_task_switch - prepare to switch tasks
  1455. * @rq: the runqueue preparing to switch
  1456. * @prev: the current task that is being switched out
  1457. * @next: the task we are going to switch to.
  1458. *
  1459. * This is called with the rq lock held and interrupts off. It must
  1460. * be paired with a subsequent finish_task_switch after the context
  1461. * switch.
  1462. *
  1463. * prepare_task_switch sets up locking and calls architecture specific
  1464. * hooks.
  1465. */
  1466. static inline void
  1467. prepare_task_switch(struct rq *rq, struct task_struct *prev,
  1468. struct task_struct *next)
  1469. {
  1470. trace_sched_switch(prev, next);
  1471. sched_info_switch(prev, next);
  1472. perf_event_task_sched_out(prev, next);
  1473. fire_sched_out_preempt_notifiers(prev, next);
  1474. prepare_lock_switch(rq, next);
  1475. prepare_arch_switch(next);
  1476. }
  1477. /**
  1478. * finish_task_switch - clean up after a task-switch
  1479. * @rq: runqueue associated with task-switch
  1480. * @prev: the thread we just switched away from.
  1481. *
  1482. * finish_task_switch must be called after the context switch, paired
  1483. * with a prepare_task_switch call before the context switch.
  1484. * finish_task_switch will reconcile locking set up by prepare_task_switch,
  1485. * and do any other architecture-specific cleanup actions.
  1486. *
  1487. * Note that we may have delayed dropping an mm in context_switch(). If
  1488. * so, we finish that here outside of the runqueue lock. (Doing it
  1489. * with the lock held can cause deadlocks; see schedule() for
  1490. * details.)
  1491. */
  1492. static void finish_task_switch(struct rq *rq, struct task_struct *prev)
  1493. __releases(rq->lock)
  1494. {
  1495. struct mm_struct *mm = rq->prev_mm;
  1496. long prev_state;
  1497. rq->prev_mm = NULL;
  1498. /*
  1499. * A task struct has one reference for the use as "current".
  1500. * If a task dies, then it sets TASK_DEAD in tsk->state and calls
  1501. * schedule one last time. The schedule call will never return, and
  1502. * the scheduled task must drop that reference.
  1503. * The test for TASK_DEAD must occur while the runqueue locks are
  1504. * still held, otherwise prev could be scheduled on another cpu, die
  1505. * there before we look at prev->state, and then the reference would
  1506. * be dropped twice.
  1507. * Manfred Spraul <manfred@colorfullife.com>
  1508. */
  1509. prev_state = prev->state;
  1510. vtime_task_switch(prev);
  1511. finish_arch_switch(prev);
  1512. perf_event_task_sched_in(prev, current);
  1513. finish_lock_switch(rq, prev);
  1514. finish_arch_post_lock_switch();
  1515. fire_sched_in_preempt_notifiers(current);
  1516. if (mm)
  1517. mmdrop(mm);
  1518. if (unlikely(prev_state == TASK_DEAD)) {
  1519. /*
  1520. * Remove function-return probe instances associated with this
  1521. * task and put them back on the free list.
  1522. */
  1523. kprobe_flush_task(prev);
  1524. put_task_struct(prev);
  1525. }
  1526. }
  1527. #ifdef CONFIG_SMP
  1528. /* assumes rq->lock is held */
  1529. static inline void pre_schedule(struct rq *rq, struct task_struct *prev)
  1530. {
  1531. if (prev->sched_class->pre_schedule)
  1532. prev->sched_class->pre_schedule(rq, prev);
  1533. }
  1534. /* rq->lock is NOT held, but preemption is disabled */
  1535. static inline void post_schedule(struct rq *rq)
  1536. {
  1537. if (rq->post_schedule) {
  1538. unsigned long flags;
  1539. raw_spin_lock_irqsave(&rq->lock, flags);
  1540. if (rq->curr->sched_class->post_schedule)
  1541. rq->curr->sched_class->post_schedule(rq);
  1542. raw_spin_unlock_irqrestore(&rq->lock, flags);
  1543. rq->post_schedule = 0;
  1544. }
  1545. }
  1546. #else
  1547. static inline void pre_schedule(struct rq *rq, struct task_struct *p)
  1548. {
  1549. }
  1550. static inline void post_schedule(struct rq *rq)
  1551. {
  1552. }
  1553. #endif
  1554. /**
  1555. * schedule_tail - first thing a freshly forked thread must call.
  1556. * @prev: the thread we just switched away from.
  1557. */
  1558. asmlinkage void schedule_tail(struct task_struct *prev)
  1559. __releases(rq->lock)
  1560. {
  1561. struct rq *rq = this_rq();
  1562. finish_task_switch(rq, prev);
  1563. /*
  1564. * FIXME: do we need to worry about rq being invalidated by the
  1565. * task_switch?
  1566. */
  1567. post_schedule(rq);
  1568. #ifdef __ARCH_WANT_UNLOCKED_CTXSW
  1569. /* In this case, finish_task_switch does not reenable preemption */
  1570. preempt_enable();
  1571. #endif
  1572. if (current->set_child_tid)
  1573. put_user(task_pid_vnr(current), current->set_child_tid);
  1574. }
  1575. /*
  1576. * context_switch - switch to the new MM and the new
  1577. * thread's register state.
  1578. */
  1579. static inline void
  1580. context_switch(struct rq *rq, struct task_struct *prev,
  1581. struct task_struct *next)
  1582. {
  1583. struct mm_struct *mm, *oldmm;
  1584. prepare_task_switch(rq, prev, next);
  1585. mm = next->mm;
  1586. oldmm = prev->active_mm;
  1587. /*
  1588. * For paravirt, this is coupled with an exit in switch_to to
  1589. * combine the page table reload and the switch backend into
  1590. * one hypercall.
  1591. */
  1592. arch_start_context_switch(prev);
  1593. if (!mm) {
  1594. next->active_mm = oldmm;
  1595. atomic_inc(&oldmm->mm_count);
  1596. enter_lazy_tlb(oldmm, next);
  1597. } else
  1598. switch_mm(oldmm, mm, next);
  1599. if (!prev->mm) {
  1600. prev->active_mm = NULL;
  1601. rq->prev_mm = oldmm;
  1602. }
  1603. /*
  1604. * Since the runqueue lock will be released by the next
  1605. * task (which is an invalid locking op but in the case
  1606. * of the scheduler it's an obvious special-case), so we
  1607. * do an early lockdep release here:
  1608. */
  1609. #ifndef __ARCH_WANT_UNLOCKED_CTXSW
  1610. spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
  1611. #endif
  1612. context_tracking_task_switch(prev, next);
  1613. /* Here we just switch the register state and the stack. */
  1614. switch_to(prev, next, prev);
  1615. barrier();
  1616. /*
  1617. * this_rq must be evaluated again because prev may have moved
  1618. * CPUs since it called schedule(), thus the 'rq' on its stack
  1619. * frame will be invalid.
  1620. */
  1621. finish_task_switch(this_rq(), prev);
  1622. }
  1623. /*
  1624. * nr_running, nr_uninterruptible and nr_context_switches:
  1625. *
  1626. * externally visible scheduler statistics: current number of runnable
  1627. * threads, current number of uninterruptible-sleeping threads, total
  1628. * number of context switches performed since bootup.
  1629. */
  1630. unsigned long nr_running(void)
  1631. {
  1632. unsigned long i, sum = 0;
  1633. for_each_online_cpu(i)
  1634. sum += cpu_rq(i)->nr_running;
  1635. return sum;
  1636. }
  1637. unsigned long nr_uninterruptible(void)
  1638. {
  1639. unsigned long i, sum = 0;
  1640. for_each_possible_cpu(i)
  1641. sum += cpu_rq(i)->nr_uninterruptible;
  1642. /*
  1643. * Since we read the counters lockless, it might be slightly
  1644. * inaccurate. Do not allow it to go below zero though:
  1645. */
  1646. if (unlikely((long)sum < 0))
  1647. sum = 0;
  1648. return sum;
  1649. }
  1650. unsigned long long nr_context_switches(void)
  1651. {
  1652. int i;
  1653. unsigned long long sum = 0;
  1654. for_each_possible_cpu(i)
  1655. sum += cpu_rq(i)->nr_switches;
  1656. return sum;
  1657. }
  1658. unsigned long nr_iowait(void)
  1659. {
  1660. unsigned long i, sum = 0;
  1661. for_each_possible_cpu(i)
  1662. sum += atomic_read(&cpu_rq(i)->nr_iowait);
  1663. return sum;
  1664. }
  1665. unsigned long nr_iowait_cpu(int cpu)
  1666. {
  1667. struct rq *this = cpu_rq(cpu);
  1668. return atomic_read(&this->nr_iowait);
  1669. }
  1670. unsigned long this_cpu_load(void)
  1671. {
  1672. struct rq *this = this_rq();
  1673. return this->cpu_load[0];
  1674. }
  1675. /*
  1676. * Global load-average calculations
  1677. *
  1678. * We take a distributed and async approach to calculating the global load-avg
  1679. * in order to minimize overhead.
  1680. *
  1681. * The global load average is an exponentially decaying average of nr_running +
  1682. * nr_uninterruptible.
  1683. *
  1684. * Once every LOAD_FREQ:
  1685. *
  1686. * nr_active = 0;
  1687. * for_each_possible_cpu(cpu)
  1688. * nr_active += cpu_of(cpu)->nr_running + cpu_of(cpu)->nr_uninterruptible;
  1689. *
  1690. * avenrun[n] = avenrun[0] * exp_n + nr_active * (1 - exp_n)
  1691. *
  1692. * Due to a number of reasons the above turns in the mess below:
  1693. *
  1694. * - for_each_possible_cpu() is prohibitively expensive on machines with
  1695. * serious number of cpus, therefore we need to take a distributed approach
  1696. * to calculating nr_active.
  1697. *
  1698. * \Sum_i x_i(t) = \Sum_i x_i(t) - x_i(t_0) | x_i(t_0) := 0
  1699. * = \Sum_i { \Sum_j=1 x_i(t_j) - x_i(t_j-1) }
  1700. *
  1701. * So assuming nr_active := 0 when we start out -- true per definition, we
  1702. * can simply take per-cpu deltas and fold those into a global accumulate
  1703. * to obtain the same result. See calc_load_fold_active().
  1704. *
  1705. * Furthermore, in order to avoid synchronizing all per-cpu delta folding
  1706. * across the machine, we assume 10 ticks is sufficient time for every
  1707. * cpu to have completed this task.
  1708. *
  1709. * This places an upper-bound on the IRQ-off latency of the machine. Then
  1710. * again, being late doesn't loose the delta, just wrecks the sample.
  1711. *
  1712. * - cpu_rq()->nr_uninterruptible isn't accurately tracked per-cpu because
  1713. * this would add another cross-cpu cacheline miss and atomic operation
  1714. * to the wakeup path. Instead we increment on whatever cpu the task ran
  1715. * when it went into uninterruptible state and decrement on whatever cpu
  1716. * did the wakeup. This means that only the sum of nr_uninterruptible over
  1717. * all cpus yields the correct result.
  1718. *
  1719. * This covers the NO_HZ=n code, for extra head-aches, see the comment below.
  1720. */
  1721. /* Variables and functions for calc_load */
  1722. static atomic_long_t calc_load_tasks;
  1723. static unsigned long calc_load_update;
  1724. unsigned long avenrun[3];
  1725. EXPORT_SYMBOL(avenrun); /* should be removed */
  1726. /**
  1727. * get_avenrun - get the load average array
  1728. * @loads: pointer to dest load array
  1729. * @offset: offset to add
  1730. * @shift: shift count to shift the result left
  1731. *
  1732. * These values are estimates at best, so no need for locking.
  1733. */
  1734. void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
  1735. {
  1736. loads[0] = (avenrun[0] + offset) << shift;
  1737. loads[1] = (avenrun[1] + offset) << shift;
  1738. loads[2] = (avenrun[2] + offset) << shift;
  1739. }
  1740. static long calc_load_fold_active(struct rq *this_rq)
  1741. {
  1742. long nr_active, delta = 0;
  1743. nr_active = this_rq->nr_running;
  1744. nr_active += (long) this_rq->nr_uninterruptible;
  1745. if (nr_active != this_rq->calc_load_active) {
  1746. delta = nr_active - this_rq->calc_load_active;
  1747. this_rq->calc_load_active = nr_active;
  1748. }
  1749. return delta;
  1750. }
  1751. /*
  1752. * a1 = a0 * e + a * (1 - e)
  1753. */
  1754. static unsigned long
  1755. calc_load(unsigned long load, unsigned long exp, unsigned long active)
  1756. {
  1757. load *= exp;
  1758. load += active * (FIXED_1 - exp);
  1759. load += 1UL << (FSHIFT - 1);
  1760. return load >> FSHIFT;
  1761. }
  1762. #ifdef CONFIG_NO_HZ
  1763. /*
  1764. * Handle NO_HZ for the global load-average.
  1765. *
  1766. * Since the above described distributed algorithm to compute the global
  1767. * load-average relies on per-cpu sampling from the tick, it is affected by
  1768. * NO_HZ.
  1769. *
  1770. * The basic idea is to fold the nr_active delta into a global idle-delta upon
  1771. * entering NO_HZ state such that we can include this as an 'extra' cpu delta
  1772. * when we read the global state.
  1773. *
  1774. * Obviously reality has to ruin such a delightfully simple scheme:
  1775. *
  1776. * - When we go NO_HZ idle during the window, we can negate our sample
  1777. * contribution, causing under-accounting.
  1778. *
  1779. * We avoid this by keeping two idle-delta counters and flipping them
  1780. * when the window starts, thus separating old and new NO_HZ load.
  1781. *
  1782. * The only trick is the slight shift in index flip for read vs write.
  1783. *
  1784. * 0s 5s 10s 15s
  1785. * +10 +10 +10 +10
  1786. * |-|-----------|-|-----------|-|-----------|-|
  1787. * r:0 0 1 1 0 0 1 1 0
  1788. * w:0 1 1 0 0 1 1 0 0
  1789. *
  1790. * This ensures we'll fold the old idle contribution in this window while
  1791. * accumlating the new one.
  1792. *
  1793. * - When we wake up from NO_HZ idle during the window, we push up our
  1794. * contribution, since we effectively move our sample point to a known
  1795. * busy state.
  1796. *
  1797. * This is solved by pushing the window forward, and thus skipping the
  1798. * sample, for this cpu (effectively using the idle-delta for this cpu which
  1799. * was in effect at the time the window opened). This also solves the issue
  1800. * of having to deal with a cpu having been in NOHZ idle for multiple
  1801. * LOAD_FREQ intervals.
  1802. *
  1803. * When making the ILB scale, we should try to pull this in as well.
  1804. */
  1805. static atomic_long_t calc_load_idle[2];
  1806. static int calc_load_idx;
  1807. static inline int calc_load_write_idx(void)
  1808. {
  1809. int idx = calc_load_idx;
  1810. /*
  1811. * See calc_global_nohz(), if we observe the new index, we also
  1812. * need to observe the new update time.
  1813. */
  1814. smp_rmb();
  1815. /*
  1816. * If the folding window started, make sure we start writing in the
  1817. * next idle-delta.
  1818. */
  1819. if (!time_before(jiffies, calc_load_update))
  1820. idx++;
  1821. return idx & 1;
  1822. }
  1823. static inline int calc_load_read_idx(void)
  1824. {
  1825. return calc_load_idx & 1;
  1826. }
  1827. void calc_load_enter_idle(void)
  1828. {
  1829. struct rq *this_rq = this_rq();
  1830. long delta;
  1831. /*
  1832. * We're going into NOHZ mode, if there's any pending delta, fold it
  1833. * into the pending idle delta.
  1834. */
  1835. delta = calc_load_fold_active(this_rq);
  1836. if (delta) {
  1837. int idx = calc_load_write_idx();
  1838. atomic_long_add(delta, &calc_load_idle[idx]);
  1839. }
  1840. }
  1841. void calc_load_exit_idle(void)
  1842. {
  1843. struct rq *this_rq = this_rq();
  1844. /*
  1845. * If we're still before the sample window, we're done.
  1846. */
  1847. if (time_before(jiffies, this_rq->calc_load_update))
  1848. return;
  1849. /*
  1850. * We woke inside or after the sample window, this means we're already
  1851. * accounted through the nohz accounting, so skip the entire deal and
  1852. * sync up for the next window.
  1853. */
  1854. this_rq->calc_load_update = calc_load_update;
  1855. if (time_before(jiffies, this_rq->calc_load_update + 10))
  1856. this_rq->calc_load_update += LOAD_FREQ;
  1857. }
  1858. static long calc_load_fold_idle(void)
  1859. {
  1860. int idx = calc_load_read_idx();
  1861. long delta = 0;
  1862. if (atomic_long_read(&calc_load_idle[idx]))
  1863. delta = atomic_long_xchg(&calc_load_idle[idx], 0);
  1864. return delta;
  1865. }
  1866. /**
  1867. * fixed_power_int - compute: x^n, in O(log n) time
  1868. *
  1869. * @x: base of the power
  1870. * @frac_bits: fractional bits of @x
  1871. * @n: power to raise @x to.
  1872. *
  1873. * By exploiting the relation between the definition of the natural power
  1874. * function: x^n := x*x*...*x (x multiplied by itself for n times), and
  1875. * the binary encoding of numbers used by computers: n := \Sum n_i * 2^i,
  1876. * (where: n_i \elem {0, 1}, the binary vector representing n),
  1877. * we find: x^n := x^(\Sum n_i * 2^i) := \Prod x^(n_i * 2^i), which is
  1878. * of course trivially computable in O(log_2 n), the length of our binary
  1879. * vector.
  1880. */
  1881. static unsigned long
  1882. fixed_power_int(unsigned long x, unsigned int frac_bits, unsigned int n)
  1883. {
  1884. unsigned long result = 1UL << frac_bits;
  1885. if (n) for (;;) {
  1886. if (n & 1) {
  1887. result *= x;
  1888. result += 1UL << (frac_bits - 1);
  1889. result >>= frac_bits;
  1890. }
  1891. n >>= 1;
  1892. if (!n)
  1893. break;
  1894. x *= x;
  1895. x += 1UL << (frac_bits - 1);
  1896. x >>= frac_bits;
  1897. }
  1898. return result;
  1899. }
  1900. /*
  1901. * a1 = a0 * e + a * (1 - e)
  1902. *
  1903. * a2 = a1 * e + a * (1 - e)
  1904. * = (a0 * e + a * (1 - e)) * e + a * (1 - e)
  1905. * = a0 * e^2 + a * (1 - e) * (1 + e)
  1906. *
  1907. * a3 = a2 * e + a * (1 - e)
  1908. * = (a0 * e^2 + a * (1 - e) * (1 + e)) * e + a * (1 - e)
  1909. * = a0 * e^3 + a * (1 - e) * (1 + e + e^2)
  1910. *
  1911. * ...
  1912. *
  1913. * an = a0 * e^n + a * (1 - e) * (1 + e + ... + e^n-1) [1]
  1914. * = a0 * e^n + a * (1 - e) * (1 - e^n)/(1 - e)
  1915. * = a0 * e^n + a * (1 - e^n)
  1916. *
  1917. * [1] application of the geometric series:
  1918. *
  1919. * n 1 - x^(n+1)
  1920. * S_n := \Sum x^i = -------------
  1921. * i=0 1 - x
  1922. */
  1923. static unsigned long
  1924. calc_load_n(unsigned long load, unsigned long exp,
  1925. unsigned long active, unsigned int n)
  1926. {
  1927. return calc_load(load, fixed_power_int(exp, FSHIFT, n), active);
  1928. }
  1929. /*
  1930. * NO_HZ can leave us missing all per-cpu ticks calling
  1931. * calc_load_account_active(), but since an idle CPU folds its delta into
  1932. * calc_load_tasks_idle per calc_load_account_idle(), all we need to do is fold
  1933. * in the pending idle delta if our idle period crossed a load cycle boundary.
  1934. *
  1935. * Once we've updated the global active value, we need to apply the exponential
  1936. * weights adjusted to the number of cycles missed.
  1937. */
  1938. static void calc_global_nohz(void)
  1939. {
  1940. long delta, active, n;
  1941. if (!time_before(jiffies, calc_load_update + 10)) {
  1942. /*
  1943. * Catch-up, fold however many we are behind still
  1944. */
  1945. delta = jiffies - calc_load_update - 10;
  1946. n = 1 + (delta / LOAD_FREQ);
  1947. active = atomic_long_read(&calc_load_tasks);
  1948. active = active > 0 ? active * FIXED_1 : 0;
  1949. avenrun[0] = calc_load_n(avenrun[0], EXP_1, active, n);
  1950. avenrun[1] = calc_load_n(avenrun[1], EXP_5, active, n);
  1951. avenrun[2] = calc_load_n(avenrun[2], EXP_15, active, n);
  1952. calc_load_update += n * LOAD_FREQ;
  1953. }
  1954. /*
  1955. * Flip the idle index...
  1956. *
  1957. * Make sure we first write the new time then flip the index, so that
  1958. * calc_load_write_idx() will see the new time when it reads the new
  1959. * index, this avoids a double flip messing things up.
  1960. */
  1961. smp_wmb();
  1962. calc_load_idx++;
  1963. }
  1964. #else /* !CONFIG_NO_HZ */
  1965. static inline long calc_load_fold_idle(void) { return 0; }
  1966. static inline void calc_global_nohz(void) { }
  1967. #endif /* CONFIG_NO_HZ */
  1968. /*
  1969. * calc_load - update the avenrun load estimates 10 ticks after the
  1970. * CPUs have updated calc_load_tasks.
  1971. */
  1972. void calc_global_load(unsigned long ticks)
  1973. {
  1974. long active, delta;
  1975. if (time_before(jiffies, calc_load_update + 10))
  1976. return;
  1977. /*
  1978. * Fold the 'old' idle-delta to include all NO_HZ cpus.
  1979. */
  1980. delta = calc_load_fold_idle();
  1981. if (delta)
  1982. atomic_long_add(delta, &calc_load_tasks);
  1983. active = atomic_long_read(&calc_load_tasks);
  1984. active = active > 0 ? active * FIXED_1 : 0;
  1985. avenrun[0] = calc_load(avenrun[0], EXP_1, active);
  1986. avenrun[1] = calc_load(avenrun[1], EXP_5, active);
  1987. avenrun[2] = calc_load(avenrun[2], EXP_15, active);
  1988. calc_load_update += LOAD_FREQ;
  1989. /*
  1990. * In case we idled for multiple LOAD_FREQ intervals, catch up in bulk.
  1991. */
  1992. calc_global_nohz();
  1993. }
  1994. /*
  1995. * Called from update_cpu_load() to periodically update this CPU's
  1996. * active count.
  1997. */
  1998. static void calc_load_account_active(struct rq *this_rq)
  1999. {
  2000. long delta;
  2001. if (time_before(jiffies, this_rq->calc_load_update))
  2002. return;
  2003. delta = calc_load_fold_active(this_rq);
  2004. if (delta)
  2005. atomic_long_add(delta, &calc_load_tasks);
  2006. this_rq->calc_load_update += LOAD_FREQ;
  2007. }
  2008. /*
  2009. * End of global load-average stuff
  2010. */
  2011. /*
  2012. * The exact cpuload at various idx values, calculated at every tick would be
  2013. * load = (2^idx - 1) / 2^idx * load + 1 / 2^idx * cur_load
  2014. *
  2015. * If a cpu misses updates for n-1 ticks (as it was idle) and update gets called
  2016. * on nth tick when cpu may be busy, then we have:
  2017. * load = ((2^idx - 1) / 2^idx)^(n-1) * load
  2018. * load = (2^idx - 1) / 2^idx) * load + 1 / 2^idx * cur_load
  2019. *
  2020. * decay_load_missed() below does efficient calculation of
  2021. * load = ((2^idx - 1) / 2^idx)^(n-1) * load
  2022. * avoiding 0..n-1 loop doing load = ((2^idx - 1) / 2^idx) * load
  2023. *
  2024. * The calculation is approximated on a 128 point scale.
  2025. * degrade_zero_ticks is the number of ticks after which load at any
  2026. * particular idx is approximated to be zero.
  2027. * degrade_factor is a precomputed table, a row for each load idx.
  2028. * Each column corresponds to degradation factor for a power of two ticks,
  2029. * based on 128 point scale.
  2030. * Example:
  2031. * row 2, col 3 (=12) says that the degradation at load idx 2 after
  2032. * 8 ticks is 12/128 (which is an approximation of exact factor 3^8/4^8).
  2033. *
  2034. * With this power of 2 load factors, we can degrade the load n times
  2035. * by looking at 1 bits in n and doing as many mult/shift instead of
  2036. * n mult/shifts needed by the exact degradation.
  2037. */
  2038. #define DEGRADE_SHIFT 7
  2039. static const unsigned char
  2040. degrade_zero_ticks[CPU_LOAD_IDX_MAX] = {0, 8, 32, 64, 128};
  2041. static const unsigned char
  2042. degrade_factor[CPU_LOAD_IDX_MAX][DEGRADE_SHIFT + 1] = {
  2043. {0, 0, 0, 0, 0, 0, 0, 0},
  2044. {64, 32, 8, 0, 0, 0, 0, 0},
  2045. {96, 72, 40, 12, 1, 0, 0},
  2046. {112, 98, 75, 43, 15, 1, 0},
  2047. {120, 112, 98, 76, 45, 16, 2} };
  2048. /*
  2049. * Update cpu_load for any missed ticks, due to tickless idle. The backlog
  2050. * would be when CPU is idle and so we just decay the old load without
  2051. * adding any new load.
  2052. */
  2053. static unsigned long
  2054. decay_load_missed(unsigned long load, unsigned long missed_updates, int idx)
  2055. {
  2056. int j = 0;
  2057. if (!missed_updates)
  2058. return load;
  2059. if (missed_updates >= degrade_zero_ticks[idx])
  2060. return 0;
  2061. if (idx == 1)
  2062. return load >> missed_updates;
  2063. while (missed_updates) {
  2064. if (missed_updates % 2)
  2065. load = (load * degrade_factor[idx][j]) >> DEGRADE_SHIFT;
  2066. missed_updates >>= 1;
  2067. j++;
  2068. }
  2069. return load;
  2070. }
  2071. /*
  2072. * Update rq->cpu_load[] statistics. This function is usually called every
  2073. * scheduler tick (TICK_NSEC). With tickless idle this will not be called
  2074. * every tick. We fix it up based on jiffies.
  2075. */
  2076. static void __update_cpu_load(struct rq *this_rq, unsigned long this_load,
  2077. unsigned long pending_updates)
  2078. {
  2079. int i, scale;
  2080. this_rq->nr_load_updates++;
  2081. /* Update our load: */
  2082. this_rq->cpu_load[0] = this_load; /* Fasttrack for idx 0 */
  2083. for (i = 1, scale = 2; i < CPU_LOAD_IDX_MAX; i++, scale += scale) {
  2084. unsigned long old_load, new_load;
  2085. /* scale is effectively 1 << i now, and >> i divides by scale */
  2086. old_load = this_rq->cpu_load[i];
  2087. old_load = decay_load_missed(old_load, pending_updates - 1, i);
  2088. new_load = this_load;
  2089. /*
  2090. * Round up the averaging division if load is increasing. This
  2091. * prevents us from getting stuck on 9 if the load is 10, for
  2092. * example.
  2093. */
  2094. if (new_load > old_load)
  2095. new_load += scale - 1;
  2096. this_rq->cpu_load[i] = (old_load * (scale - 1) + new_load) >> i;
  2097. }
  2098. sched_avg_update(this_rq);
  2099. }
  2100. #ifdef CONFIG_NO_HZ
  2101. /*
  2102. * There is no sane way to deal with nohz on smp when using jiffies because the
  2103. * cpu doing the jiffies update might drift wrt the cpu doing the jiffy reading
  2104. * causing off-by-one errors in observed deltas; {0,2} instead of {1,1}.
  2105. *
  2106. * Therefore we cannot use the delta approach from the regular tick since that
  2107. * would seriously skew the load calculation. However we'll make do for those
  2108. * updates happening while idle (nohz_idle_balance) or coming out of idle
  2109. * (tick_nohz_idle_exit).
  2110. *
  2111. * This means we might still be one tick off for nohz periods.
  2112. */
  2113. /*
  2114. * Called from nohz_idle_balance() to update the load ratings before doing the
  2115. * idle balance.
  2116. */
  2117. void update_idle_cpu_load(struct rq *this_rq)
  2118. {
  2119. unsigned long curr_jiffies = ACCESS_ONCE(jiffies);
  2120. unsigned long load = this_rq->load.weight;
  2121. unsigned long pending_updates;
  2122. /*
  2123. * bail if there's load or we're actually up-to-date.
  2124. */
  2125. if (load || curr_jiffies == this_rq->last_load_update_tick)
  2126. return;
  2127. pending_updates = curr_jiffies - this_rq->last_load_update_tick;
  2128. this_rq->last_load_update_tick = curr_jiffies;
  2129. __update_cpu_load(this_rq, load, pending_updates);
  2130. }
  2131. /*
  2132. * Called from tick_nohz_idle_exit() -- try and fix up the ticks we missed.
  2133. */
  2134. void update_cpu_load_nohz(void)
  2135. {
  2136. struct rq *this_rq = this_rq();
  2137. unsigned long curr_jiffies = ACCESS_ONCE(jiffies);
  2138. unsigned long pending_updates;
  2139. if (curr_jiffies == this_rq->last_load_update_tick)
  2140. return;
  2141. raw_spin_lock(&this_rq->lock);
  2142. pending_updates = curr_jiffies - this_rq->last_load_update_tick;
  2143. if (pending_updates) {
  2144. this_rq->last_load_update_tick = curr_jiffies;
  2145. /*
  2146. * We were idle, this means load 0, the current load might be
  2147. * !0 due to remote wakeups and the sort.
  2148. */
  2149. __update_cpu_load(this_rq, 0, pending_updates);
  2150. }
  2151. raw_spin_unlock(&this_rq->lock);
  2152. }
  2153. #endif /* CONFIG_NO_HZ */
  2154. /*
  2155. * Called from scheduler_tick()
  2156. */
  2157. static void update_cpu_load_active(struct rq *this_rq)
  2158. {
  2159. /*
  2160. * See the mess around update_idle_cpu_load() / update_cpu_load_nohz().
  2161. */
  2162. this_rq->last_load_update_tick = jiffies;
  2163. __update_cpu_load(this_rq, this_rq->load.weight, 1);
  2164. calc_load_account_active(this_rq);
  2165. }
  2166. #ifdef CONFIG_SMP
  2167. /*
  2168. * sched_exec - execve() is a valuable balancing opportunity, because at
  2169. * this point the task has the smallest effective memory and cache footprint.
  2170. */
  2171. void sched_exec(void)
  2172. {
  2173. struct task_struct *p = current;
  2174. unsigned long flags;
  2175. int dest_cpu;
  2176. raw_spin_lock_irqsave(&p->pi_lock, flags);
  2177. dest_cpu = p->sched_class->select_task_rq(p, SD_BALANCE_EXEC, 0);
  2178. if (dest_cpu == smp_processor_id())
  2179. goto unlock;
  2180. if (likely(cpu_active(dest_cpu))) {
  2181. struct migration_arg arg = { p, dest_cpu };
  2182. raw_spin_unlock_irqrestore(&p->pi_lock, flags);
  2183. stop_one_cpu(task_cpu(p), migration_cpu_stop, &arg);
  2184. return;
  2185. }
  2186. unlock:
  2187. raw_spin_unlock_irqrestore(&p->pi_lock, flags);
  2188. }
  2189. #endif
  2190. DEFINE_PER_CPU(struct kernel_stat, kstat);
  2191. DEFINE_PER_CPU(struct kernel_cpustat, kernel_cpustat);
  2192. EXPORT_PER_CPU_SYMBOL(kstat);
  2193. EXPORT_PER_CPU_SYMBOL(kernel_cpustat);
  2194. /*
  2195. * Return any ns on the sched_clock that have not yet been accounted in
  2196. * @p in case that task is currently running.
  2197. *
  2198. * Called with task_rq_lock() held on @rq.
  2199. */
  2200. static u64 do_task_delta_exec(struct task_struct *p, struct rq *rq)
  2201. {
  2202. u64 ns = 0;
  2203. if (task_current(rq, p)) {
  2204. update_rq_clock(rq);
  2205. ns = rq->clock_task - p->se.exec_start;
  2206. if ((s64)ns < 0)
  2207. ns = 0;
  2208. }
  2209. return ns;
  2210. }
  2211. unsigned long long task_delta_exec(struct task_struct *p)
  2212. {
  2213. unsigned long flags;
  2214. struct rq *rq;
  2215. u64 ns = 0;
  2216. rq = task_rq_lock(p, &flags);
  2217. ns = do_task_delta_exec(p, rq);
  2218. task_rq_unlock(rq, p, &flags);
  2219. return ns;
  2220. }
  2221. /*
  2222. * Return accounted runtime for the task.
  2223. * In case the task is currently running, return the runtime plus current's
  2224. * pending runtime that have not been accounted yet.
  2225. */
  2226. unsigned long long task_sched_runtime(struct task_struct *p)
  2227. {
  2228. unsigned long flags;
  2229. struct rq *rq;
  2230. u64 ns = 0;
  2231. rq = task_rq_lock(p, &flags);
  2232. ns = p->se.sum_exec_runtime + do_task_delta_exec(p, rq);
  2233. task_rq_unlock(rq, p, &flags);
  2234. return ns;
  2235. }
  2236. /*
  2237. * This function gets called by the timer code, with HZ frequency.
  2238. * We call it with interrupts disabled.
  2239. */
  2240. void scheduler_tick(void)
  2241. {
  2242. int cpu = smp_processor_id();
  2243. struct rq *rq = cpu_rq(cpu);
  2244. struct task_struct *curr = rq->curr;
  2245. sched_clock_tick();
  2246. raw_spin_lock(&rq->lock);
  2247. update_rq_clock(rq);
  2248. update_cpu_load_active(rq);
  2249. curr->sched_class->task_tick(rq, curr, 0);
  2250. raw_spin_unlock(&rq->lock);
  2251. perf_event_task_tick();
  2252. #ifdef CONFIG_SMP
  2253. rq->idle_balance = idle_cpu(cpu);
  2254. trigger_load_balance(rq, cpu);
  2255. #endif
  2256. }
  2257. notrace unsigned long get_parent_ip(unsigned long addr)
  2258. {
  2259. if (in_lock_functions(addr)) {
  2260. addr = CALLER_ADDR2;
  2261. if (in_lock_functions(addr))
  2262. addr = CALLER_ADDR3;
  2263. }
  2264. return addr;
  2265. }
  2266. #if defined(CONFIG_PREEMPT) && (defined(CONFIG_DEBUG_PREEMPT) || \
  2267. defined(CONFIG_PREEMPT_TRACER))
  2268. void __kprobes add_preempt_count(int val)
  2269. {
  2270. #ifdef CONFIG_DEBUG_PREEMPT
  2271. /*
  2272. * Underflow?
  2273. */
  2274. if (DEBUG_LOCKS_WARN_ON((preempt_count() < 0)))
  2275. return;
  2276. #endif
  2277. preempt_count() += val;
  2278. #ifdef CONFIG_DEBUG_PREEMPT
  2279. /*
  2280. * Spinlock count overflowing soon?
  2281. */
  2282. DEBUG_LOCKS_WARN_ON((preempt_count() & PREEMPT_MASK) >=
  2283. PREEMPT_MASK - 10);
  2284. #endif
  2285. if (preempt_count() == val)
  2286. trace_preempt_off(CALLER_ADDR0, get_parent_ip(CALLER_ADDR1));
  2287. }
  2288. EXPORT_SYMBOL(add_preempt_count);
  2289. void __kprobes sub_preempt_count(int val)
  2290. {
  2291. #ifdef CONFIG_DEBUG_PREEMPT
  2292. /*
  2293. * Underflow?
  2294. */
  2295. if (DEBUG_LOCKS_WARN_ON(val > preempt_count()))
  2296. return;
  2297. /*
  2298. * Is the spinlock portion underflowing?
  2299. */
  2300. if (DEBUG_LOCKS_WARN_ON((val < PREEMPT_MASK) &&
  2301. !(preempt_count() & PREEMPT_MASK)))
  2302. return;
  2303. #endif
  2304. if (preempt_count() == val)
  2305. trace_preempt_on(CALLER_ADDR0, get_parent_ip(CALLER_ADDR1));
  2306. preempt_count() -= val;
  2307. }
  2308. EXPORT_SYMBOL(sub_preempt_count);
  2309. #endif
  2310. /*
  2311. * Print scheduling while atomic bug:
  2312. */
  2313. static noinline void __schedule_bug(struct task_struct *prev)
  2314. {
  2315. if (oops_in_progress)
  2316. return;
  2317. printk(KERN_ERR "BUG: scheduling while atomic: %s/%d/0x%08x\n",
  2318. prev->comm, prev->pid, preempt_count());
  2319. debug_show_held_locks(prev);
  2320. print_modules();
  2321. if (irqs_disabled())
  2322. print_irqtrace_events(prev);
  2323. dump_stack();
  2324. add_taint(TAINT_WARN);
  2325. }
  2326. /*
  2327. * Various schedule()-time debugging checks and statistics:
  2328. */
  2329. static inline void schedule_debug(struct task_struct *prev)
  2330. {
  2331. /*
  2332. * Test if we are atomic. Since do_exit() needs to call into
  2333. * schedule() atomically, we ignore that path for now.
  2334. * Otherwise, whine if we are scheduling when we should not be.
  2335. */
  2336. if (unlikely(in_atomic_preempt_off() && !prev->exit_state))
  2337. __schedule_bug(prev);
  2338. rcu_sleep_check();
  2339. profile_hit(SCHED_PROFILING, __builtin_return_address(0));
  2340. schedstat_inc(this_rq(), sched_count);
  2341. }
  2342. static void put_prev_task(struct rq *rq, struct task_struct *prev)
  2343. {
  2344. if (prev->on_rq || rq->skip_clock_update < 0)
  2345. update_rq_clock(rq);
  2346. prev->sched_class->put_prev_task(rq, prev);
  2347. }
  2348. /*
  2349. * Pick up the highest-prio task:
  2350. */
  2351. static inline struct task_struct *
  2352. pick_next_task(struct rq *rq)
  2353. {
  2354. const struct sched_class *class;
  2355. struct task_struct *p;
  2356. /*
  2357. * Optimization: we know that if all tasks are in
  2358. * the fair class we can call that function directly:
  2359. */
  2360. if (likely(rq->nr_running == rq->cfs.h_nr_running)) {
  2361. p = fair_sched_class.pick_next_task(rq);
  2362. if (likely(p))
  2363. return p;
  2364. }
  2365. for_each_class(class) {
  2366. p = class->pick_next_task(rq);
  2367. if (p)
  2368. return p;
  2369. }
  2370. BUG(); /* the idle class will always have a runnable task */
  2371. }
  2372. /*
  2373. * __schedule() is the main scheduler function.
  2374. *
  2375. * The main means of driving the scheduler and thus entering this function are:
  2376. *
  2377. * 1. Explicit blocking: mutex, semaphore, waitqueue, etc.
  2378. *
  2379. * 2. TIF_NEED_RESCHED flag is checked on interrupt and userspace return
  2380. * paths. For example, see arch/x86/entry_64.S.
  2381. *
  2382. * To drive preemption between tasks, the scheduler sets the flag in timer
  2383. * interrupt handler scheduler_tick().
  2384. *
  2385. * 3. Wakeups don't really cause entry into schedule(). They add a
  2386. * task to the run-queue and that's it.
  2387. *
  2388. * Now, if the new task added to the run-queue preempts the current
  2389. * task, then the wakeup sets TIF_NEED_RESCHED and schedule() gets
  2390. * called on the nearest possible occasion:
  2391. *
  2392. * - If the kernel is preemptible (CONFIG_PREEMPT=y):
  2393. *
  2394. * - in syscall or exception context, at the next outmost
  2395. * preempt_enable(). (this might be as soon as the wake_up()'s
  2396. * spin_unlock()!)
  2397. *
  2398. * - in IRQ context, return from interrupt-handler to
  2399. * preemptible context
  2400. *
  2401. * - If the kernel is not preemptible (CONFIG_PREEMPT is not set)
  2402. * then at the next:
  2403. *
  2404. * - cond_resched() call
  2405. * - explicit schedule() call
  2406. * - return from syscall or exception to user-space
  2407. * - return from interrupt-handler to user-space
  2408. */
  2409. static void __sched __schedule(void)
  2410. {
  2411. struct task_struct *prev, *next;
  2412. unsigned long *switch_count;
  2413. struct rq *rq;
  2414. int cpu;
  2415. need_resched:
  2416. preempt_disable();
  2417. cpu = smp_processor_id();
  2418. rq = cpu_rq(cpu);
  2419. rcu_note_context_switch(cpu);
  2420. prev = rq->curr;
  2421. schedule_debug(prev);
  2422. if (sched_feat(HRTICK))
  2423. hrtick_clear(rq);
  2424. raw_spin_lock_irq(&rq->lock);
  2425. switch_count = &prev->nivcsw;
  2426. if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
  2427. if (unlikely(signal_pending_state(prev->state, prev))) {
  2428. prev->state = TASK_RUNNING;
  2429. } else {
  2430. deactivate_task(rq, prev, DEQUEUE_SLEEP);
  2431. prev->on_rq = 0;
  2432. /*
  2433. * If a worker went to sleep, notify and ask workqueue
  2434. * whether it wants to wake up a task to maintain
  2435. * concurrency.
  2436. */
  2437. if (prev->flags & PF_WQ_WORKER) {
  2438. struct task_struct *to_wakeup;
  2439. to_wakeup = wq_worker_sleeping(prev, cpu);
  2440. if (to_wakeup)
  2441. try_to_wake_up_local(to_wakeup);
  2442. }
  2443. }
  2444. switch_count = &prev->nvcsw;
  2445. }
  2446. pre_schedule(rq, prev);
  2447. if (unlikely(!rq->nr_running))
  2448. idle_balance(cpu, rq);
  2449. put_prev_task(rq, prev);
  2450. next = pick_next_task(rq);
  2451. clear_tsk_need_resched(prev);
  2452. rq->skip_clock_update = 0;
  2453. if (likely(prev != next)) {
  2454. rq->nr_switches++;
  2455. rq->curr = next;
  2456. ++*switch_count;
  2457. context_switch(rq, prev, next); /* unlocks the rq */
  2458. /*
  2459. * The context switch have flipped the stack from under us
  2460. * and restored the local variables which were saved when
  2461. * this task called schedule() in the past. prev == current
  2462. * is still correct, but it can be moved to another cpu/rq.
  2463. */
  2464. cpu = smp_processor_id();
  2465. rq = cpu_rq(cpu);
  2466. } else
  2467. raw_spin_unlock_irq(&rq->lock);
  2468. post_schedule(rq);
  2469. sched_preempt_enable_no_resched();
  2470. if (need_resched())
  2471. goto need_resched;
  2472. }
  2473. static inline void sched_submit_work(struct task_struct *tsk)
  2474. {
  2475. if (!tsk->state || tsk_is_pi_blocked(tsk))
  2476. return;
  2477. /*
  2478. * If we are going to sleep and we have plugged IO queued,
  2479. * make sure to submit it to avoid deadlocks.
  2480. */
  2481. if (blk_needs_flush_plug(tsk))
  2482. blk_schedule_flush_plug(tsk);
  2483. }
  2484. asmlinkage void __sched schedule(void)
  2485. {
  2486. struct task_struct *tsk = current;
  2487. sched_submit_work(tsk);
  2488. __schedule();
  2489. }
  2490. EXPORT_SYMBOL(schedule);
  2491. #ifdef CONFIG_CONTEXT_TRACKING
  2492. asmlinkage void __sched schedule_user(void)
  2493. {
  2494. /*
  2495. * If we come here after a random call to set_need_resched(),
  2496. * or we have been woken up remotely but the IPI has not yet arrived,
  2497. * we haven't yet exited the RCU idle mode. Do it here manually until
  2498. * we find a better solution.
  2499. */
  2500. user_exit();
  2501. schedule();
  2502. user_enter();
  2503. }
  2504. #endif
  2505. /**
  2506. * schedule_preempt_disabled - called with preemption disabled
  2507. *
  2508. * Returns with preemption disabled. Note: preempt_count must be 1
  2509. */
  2510. void __sched schedule_preempt_disabled(void)
  2511. {
  2512. sched_preempt_enable_no_resched();
  2513. schedule();
  2514. preempt_disable();
  2515. }
  2516. #ifdef CONFIG_MUTEX_SPIN_ON_OWNER
  2517. static inline bool owner_running(struct mutex *lock, struct task_struct *owner)
  2518. {
  2519. if (lock->owner != owner)
  2520. return false;
  2521. /*
  2522. * Ensure we emit the owner->on_cpu, dereference _after_ checking
  2523. * lock->owner still matches owner, if that fails, owner might
  2524. * point to free()d memory, if it still matches, the rcu_read_lock()
  2525. * ensures the memory stays valid.
  2526. */
  2527. barrier();
  2528. return owner->on_cpu;
  2529. }
  2530. /*
  2531. * Look out! "owner" is an entirely speculative pointer
  2532. * access and not reliable.
  2533. */
  2534. int mutex_spin_on_owner(struct mutex *lock, struct task_struct *owner)
  2535. {
  2536. if (!sched_feat(OWNER_SPIN))
  2537. return 0;
  2538. rcu_read_lock();
  2539. while (owner_running(lock, owner)) {
  2540. if (need_resched())
  2541. break;
  2542. arch_mutex_cpu_relax();
  2543. }
  2544. rcu_read_unlock();
  2545. /*
  2546. * We break out the loop above on need_resched() and when the
  2547. * owner changed, which is a sign for heavy contention. Return
  2548. * success only when lock->owner is NULL.
  2549. */
  2550. return lock->owner == NULL;
  2551. }
  2552. #endif
  2553. #ifdef CONFIG_PREEMPT
  2554. /*
  2555. * this is the entry point to schedule() from in-kernel preemption
  2556. * off of preempt_enable. Kernel preemptions off return from interrupt
  2557. * occur there and call schedule directly.
  2558. */
  2559. asmlinkage void __sched notrace preempt_schedule(void)
  2560. {
  2561. struct thread_info *ti = current_thread_info();
  2562. /*
  2563. * If there is a non-zero preempt_count or interrupts are disabled,
  2564. * we do not want to preempt the current task. Just return..
  2565. */
  2566. if (likely(ti->preempt_count || irqs_disabled()))
  2567. return;
  2568. do {
  2569. add_preempt_count_notrace(PREEMPT_ACTIVE);
  2570. __schedule();
  2571. sub_preempt_count_notrace(PREEMPT_ACTIVE);
  2572. /*
  2573. * Check again in case we missed a preemption opportunity
  2574. * between schedule and now.
  2575. */
  2576. barrier();
  2577. } while (need_resched());
  2578. }
  2579. EXPORT_SYMBOL(preempt_schedule);
  2580. /*
  2581. * this is the entry point to schedule() from kernel preemption
  2582. * off of irq context.
  2583. * Note, that this is called and return with irqs disabled. This will
  2584. * protect us against recursive calling from irq.
  2585. */
  2586. asmlinkage void __sched preempt_schedule_irq(void)
  2587. {
  2588. struct thread_info *ti = current_thread_info();
  2589. /* Catch callers which need to be fixed */
  2590. BUG_ON(ti->preempt_count || !irqs_disabled());
  2591. user_exit();
  2592. do {
  2593. add_preempt_count(PREEMPT_ACTIVE);
  2594. local_irq_enable();
  2595. __schedule();
  2596. local_irq_disable();
  2597. sub_preempt_count(PREEMPT_ACTIVE);
  2598. /*
  2599. * Check again in case we missed a preemption opportunity
  2600. * between schedule and now.
  2601. */
  2602. barrier();
  2603. } while (need_resched());
  2604. }
  2605. #endif /* CONFIG_PREEMPT */
  2606. int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,
  2607. void *key)
  2608. {
  2609. return try_to_wake_up(curr->private, mode, wake_flags);
  2610. }
  2611. EXPORT_SYMBOL(default_wake_function);
  2612. /*
  2613. * The core wakeup function. Non-exclusive wakeups (nr_exclusive == 0) just
  2614. * wake everything up. If it's an exclusive wakeup (nr_exclusive == small +ve
  2615. * number) then we wake all the non-exclusive tasks and one exclusive task.
  2616. *
  2617. * There are circumstances in which we can try to wake a task which has already
  2618. * started to run but is not in state TASK_RUNNING. try_to_wake_up() returns
  2619. * zero in this (rare) case, and we handle it by continuing to scan the queue.
  2620. */
  2621. static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
  2622. int nr_exclusive, int wake_flags, void *key)
  2623. {
  2624. wait_queue_t *curr, *next;
  2625. list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
  2626. unsigned flags = curr->flags;
  2627. if (curr->func(curr, mode, wake_flags, key) &&
  2628. (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
  2629. break;
  2630. }
  2631. }
  2632. /**
  2633. * __wake_up - wake up threads blocked on a waitqueue.
  2634. * @q: the waitqueue
  2635. * @mode: which threads
  2636. * @nr_exclusive: how many wake-one or wake-many threads to wake up
  2637. * @key: is directly passed to the wakeup function
  2638. *
  2639. * It may be assumed that this function implies a write memory barrier before
  2640. * changing the task state if and only if any tasks are woken up.
  2641. */
  2642. void __wake_up(wait_queue_head_t *q, unsigned int mode,
  2643. int nr_exclusive, void *key)
  2644. {
  2645. unsigned long flags;
  2646. spin_lock_irqsave(&q->lock, flags);
  2647. __wake_up_common(q, mode, nr_exclusive, 0, key);
  2648. spin_unlock_irqrestore(&q->lock, flags);
  2649. }
  2650. EXPORT_SYMBOL(__wake_up);
  2651. /*
  2652. * Same as __wake_up but called with the spinlock in wait_queue_head_t held.
  2653. */
  2654. void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr)
  2655. {
  2656. __wake_up_common(q, mode, nr, 0, NULL);
  2657. }
  2658. EXPORT_SYMBOL_GPL(__wake_up_locked);
  2659. void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key)
  2660. {
  2661. __wake_up_common(q, mode, 1, 0, key);
  2662. }
  2663. EXPORT_SYMBOL_GPL(__wake_up_locked_key);
  2664. /**
  2665. * __wake_up_sync_key - wake up threads blocked on a waitqueue.
  2666. * @q: the waitqueue
  2667. * @mode: which threads
  2668. * @nr_exclusive: how many wake-one or wake-many threads to wake up
  2669. * @key: opaque value to be passed to wakeup targets
  2670. *
  2671. * The sync wakeup differs that the waker knows that it will schedule
  2672. * away soon, so while the target thread will be woken up, it will not
  2673. * be migrated to another CPU - ie. the two threads are 'synchronized'
  2674. * with each other. This can prevent needless bouncing between CPUs.
  2675. *
  2676. * On UP it can prevent extra preemption.
  2677. *
  2678. * It may be assumed that this function implies a write memory barrier before
  2679. * changing the task state if and only if any tasks are woken up.
  2680. */
  2681. void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
  2682. int nr_exclusive, void *key)
  2683. {
  2684. unsigned long flags;
  2685. int wake_flags = WF_SYNC;
  2686. if (unlikely(!q))
  2687. return;
  2688. if (unlikely(!nr_exclusive))
  2689. wake_flags = 0;
  2690. spin_lock_irqsave(&q->lock, flags);
  2691. __wake_up_common(q, mode, nr_exclusive, wake_flags, key);
  2692. spin_unlock_irqrestore(&q->lock, flags);
  2693. }
  2694. EXPORT_SYMBOL_GPL(__wake_up_sync_key);
  2695. /*
  2696. * __wake_up_sync - see __wake_up_sync_key()
  2697. */
  2698. void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
  2699. {
  2700. __wake_up_sync_key(q, mode, nr_exclusive, NULL);
  2701. }
  2702. EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */
  2703. /**
  2704. * complete: - signals a single thread waiting on this completion
  2705. * @x: holds the state of this particular completion
  2706. *
  2707. * This will wake up a single thread waiting on this completion. Threads will be
  2708. * awakened in the same order in which they were queued.
  2709. *
  2710. * See also complete_all(), wait_for_completion() and related routines.
  2711. *
  2712. * It may be assumed that this function implies a write memory barrier before
  2713. * changing the task state if and only if any tasks are woken up.
  2714. */
  2715. void complete(struct completion *x)
  2716. {
  2717. unsigned long flags;
  2718. spin_lock_irqsave(&x->wait.lock, flags);
  2719. x->done++;
  2720. __wake_up_common(&x->wait, TASK_NORMAL, 1, 0, NULL);
  2721. spin_unlock_irqrestore(&x->wait.lock, flags);
  2722. }
  2723. EXPORT_SYMBOL(complete);
  2724. /**
  2725. * complete_all: - signals all threads waiting on this completion
  2726. * @x: holds the state of this particular completion
  2727. *
  2728. * This will wake up all threads waiting on this particular completion event.
  2729. *
  2730. * It may be assumed that this function implies a write memory barrier before
  2731. * changing the task state if and only if any tasks are woken up.
  2732. */
  2733. void complete_all(struct completion *x)
  2734. {
  2735. unsigned long flags;
  2736. spin_lock_irqsave(&x->wait.lock, flags);
  2737. x->done += UINT_MAX/2;
  2738. __wake_up_common(&x->wait, TASK_NORMAL, 0, 0, NULL);
  2739. spin_unlock_irqrestore(&x->wait.lock, flags);
  2740. }
  2741. EXPORT_SYMBOL(complete_all);
  2742. static inline long __sched
  2743. do_wait_for_common(struct completion *x, long timeout, int state)
  2744. {
  2745. if (!x->done) {
  2746. DECLARE_WAITQUEUE(wait, current);
  2747. __add_wait_queue_tail_exclusive(&x->wait, &wait);
  2748. do {
  2749. if (signal_pending_state(state, current)) {
  2750. timeout = -ERESTARTSYS;
  2751. break;
  2752. }
  2753. __set_current_state(state);
  2754. spin_unlock_irq(&x->wait.lock);
  2755. timeout = schedule_timeout(timeout);
  2756. spin_lock_irq(&x->wait.lock);
  2757. } while (!x->done && timeout);
  2758. __remove_wait_queue(&x->wait, &wait);
  2759. if (!x->done)
  2760. return timeout;
  2761. }
  2762. x->done--;
  2763. return timeout ?: 1;
  2764. }
  2765. static long __sched
  2766. wait_for_common(struct completion *x, long timeout, int state)
  2767. {
  2768. might_sleep();
  2769. spin_lock_irq(&x->wait.lock);
  2770. timeout = do_wait_for_common(x, timeout, state);
  2771. spin_unlock_irq(&x->wait.lock);
  2772. return timeout;
  2773. }
  2774. /**
  2775. * wait_for_completion: - waits for completion of a task
  2776. * @x: holds the state of this particular completion
  2777. *
  2778. * This waits to be signaled for completion of a specific task. It is NOT
  2779. * interruptible and there is no timeout.
  2780. *
  2781. * See also similar routines (i.e. wait_for_completion_timeout()) with timeout
  2782. * and interrupt capability. Also see complete().
  2783. */
  2784. void __sched wait_for_completion(struct completion *x)
  2785. {
  2786. wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
  2787. }
  2788. EXPORT_SYMBOL(wait_for_completion);
  2789. /**
  2790. * wait_for_completion_timeout: - waits for completion of a task (w/timeout)
  2791. * @x: holds the state of this particular completion
  2792. * @timeout: timeout value in jiffies
  2793. *
  2794. * This waits for either a completion of a specific task to be signaled or for a
  2795. * specified timeout to expire. The timeout is in jiffies. It is not
  2796. * interruptible.
  2797. *
  2798. * The return value is 0 if timed out, and positive (at least 1, or number of
  2799. * jiffies left till timeout) if completed.
  2800. */
  2801. unsigned long __sched
  2802. wait_for_completion_timeout(struct completion *x, unsigned long timeout)
  2803. {
  2804. return wait_for_common(x, timeout, TASK_UNINTERRUPTIBLE);
  2805. }
  2806. EXPORT_SYMBOL(wait_for_completion_timeout);
  2807. /**
  2808. * wait_for_completion_interruptible: - waits for completion of a task (w/intr)
  2809. * @x: holds the state of this particular completion
  2810. *
  2811. * This waits for completion of a specific task to be signaled. It is
  2812. * interruptible.
  2813. *
  2814. * The return value is -ERESTARTSYS if interrupted, 0 if completed.
  2815. */
  2816. int __sched wait_for_completion_interruptible(struct completion *x)
  2817. {
  2818. long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_INTERRUPTIBLE);
  2819. if (t == -ERESTARTSYS)
  2820. return t;
  2821. return 0;
  2822. }
  2823. EXPORT_SYMBOL(wait_for_completion_interruptible);
  2824. /**
  2825. * wait_for_completion_interruptible_timeout: - waits for completion (w/(to,intr))
  2826. * @x: holds the state of this particular completion
  2827. * @timeout: timeout value in jiffies
  2828. *
  2829. * This waits for either a completion of a specific task to be signaled or for a
  2830. * specified timeout to expire. It is interruptible. The timeout is in jiffies.
  2831. *
  2832. * The return value is -ERESTARTSYS if interrupted, 0 if timed out,
  2833. * positive (at least 1, or number of jiffies left till timeout) if completed.
  2834. */
  2835. long __sched
  2836. wait_for_completion_interruptible_timeout(struct completion *x,
  2837. unsigned long timeout)
  2838. {
  2839. return wait_for_common(x, timeout, TASK_INTERRUPTIBLE);
  2840. }
  2841. EXPORT_SYMBOL(wait_for_completion_interruptible_timeout);
  2842. /**
  2843. * wait_for_completion_killable: - waits for completion of a task (killable)
  2844. * @x: holds the state of this particular completion
  2845. *
  2846. * This waits to be signaled for completion of a specific task. It can be
  2847. * interrupted by a kill signal.
  2848. *
  2849. * The return value is -ERESTARTSYS if interrupted, 0 if completed.
  2850. */
  2851. int __sched wait_for_completion_killable(struct completion *x)
  2852. {
  2853. long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_KILLABLE);
  2854. if (t == -ERESTARTSYS)
  2855. return t;
  2856. return 0;
  2857. }
  2858. EXPORT_SYMBOL(wait_for_completion_killable);
  2859. /**
  2860. * wait_for_completion_killable_timeout: - waits for completion of a task (w/(to,killable))
  2861. * @x: holds the state of this particular completion
  2862. * @timeout: timeout value in jiffies
  2863. *
  2864. * This waits for either a completion of a specific task to be
  2865. * signaled or for a specified timeout to expire. It can be
  2866. * interrupted by a kill signal. The timeout is in jiffies.
  2867. *
  2868. * The return value is -ERESTARTSYS if interrupted, 0 if timed out,
  2869. * positive (at least 1, or number of jiffies left till timeout) if completed.
  2870. */
  2871. long __sched
  2872. wait_for_completion_killable_timeout(struct completion *x,
  2873. unsigned long timeout)
  2874. {
  2875. return wait_for_common(x, timeout, TASK_KILLABLE);
  2876. }
  2877. EXPORT_SYMBOL(wait_for_completion_killable_timeout);
  2878. /**
  2879. * try_wait_for_completion - try to decrement a completion without blocking
  2880. * @x: completion structure
  2881. *
  2882. * Returns: 0 if a decrement cannot be done without blocking
  2883. * 1 if a decrement succeeded.
  2884. *
  2885. * If a completion is being used as a counting completion,
  2886. * attempt to decrement the counter without blocking. This
  2887. * enables us to avoid waiting if the resource the completion
  2888. * is protecting is not available.
  2889. */
  2890. bool try_wait_for_completion(struct completion *x)
  2891. {
  2892. unsigned long flags;
  2893. int ret = 1;
  2894. spin_lock_irqsave(&x->wait.lock, flags);
  2895. if (!x->done)
  2896. ret = 0;
  2897. else
  2898. x->done--;
  2899. spin_unlock_irqrestore(&x->wait.lock, flags);
  2900. return ret;
  2901. }
  2902. EXPORT_SYMBOL(try_wait_for_completion);
  2903. /**
  2904. * completion_done - Test to see if a completion has any waiters
  2905. * @x: completion structure
  2906. *
  2907. * Returns: 0 if there are waiters (wait_for_completion() in progress)
  2908. * 1 if there are no waiters.
  2909. *
  2910. */
  2911. bool completion_done(struct completion *x)
  2912. {
  2913. unsigned long flags;
  2914. int ret = 1;
  2915. spin_lock_irqsave(&x->wait.lock, flags);
  2916. if (!x->done)
  2917. ret = 0;
  2918. spin_unlock_irqrestore(&x->wait.lock, flags);
  2919. return ret;
  2920. }
  2921. EXPORT_SYMBOL(completion_done);
  2922. static long __sched
  2923. sleep_on_common(wait_queue_head_t *q, int state, long timeout)
  2924. {
  2925. unsigned long flags;
  2926. wait_queue_t wait;
  2927. init_waitqueue_entry(&wait, current);
  2928. __set_current_state(state);
  2929. spin_lock_irqsave(&q->lock, flags);
  2930. __add_wait_queue(q, &wait);
  2931. spin_unlock(&q->lock);
  2932. timeout = schedule_timeout(timeout);
  2933. spin_lock_irq(&q->lock);
  2934. __remove_wait_queue(q, &wait);
  2935. spin_unlock_irqrestore(&q->lock, flags);
  2936. return timeout;
  2937. }
  2938. void __sched interruptible_sleep_on(wait_queue_head_t *q)
  2939. {
  2940. sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
  2941. }
  2942. EXPORT_SYMBOL(interruptible_sleep_on);
  2943. long __sched
  2944. interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
  2945. {
  2946. return sleep_on_common(q, TASK_INTERRUPTIBLE, timeout);
  2947. }
  2948. EXPORT_SYMBOL(interruptible_sleep_on_timeout);
  2949. void __sched sleep_on(wait_queue_head_t *q)
  2950. {
  2951. sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
  2952. }
  2953. EXPORT_SYMBOL(sleep_on);
  2954. long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout)
  2955. {
  2956. return sleep_on_common(q, TASK_UNINTERRUPTIBLE, timeout);
  2957. }
  2958. EXPORT_SYMBOL(sleep_on_timeout);
  2959. #ifdef CONFIG_RT_MUTEXES
  2960. /*
  2961. * rt_mutex_setprio - set the current priority of a task
  2962. * @p: task
  2963. * @prio: prio value (kernel-internal form)
  2964. *
  2965. * This function changes the 'effective' priority of a task. It does
  2966. * not touch ->normal_prio like __setscheduler().
  2967. *
  2968. * Used by the rt_mutex code to implement priority inheritance logic.
  2969. */
  2970. void rt_mutex_setprio(struct task_struct *p, int prio)
  2971. {
  2972. int oldprio, on_rq, running;
  2973. struct rq *rq;
  2974. const struct sched_class *prev_class;
  2975. BUG_ON(prio < 0 || prio > MAX_PRIO);
  2976. rq = __task_rq_lock(p);
  2977. /*
  2978. * Idle task boosting is a nono in general. There is one
  2979. * exception, when PREEMPT_RT and NOHZ is active:
  2980. *
  2981. * The idle task calls get_next_timer_interrupt() and holds
  2982. * the timer wheel base->lock on the CPU and another CPU wants
  2983. * to access the timer (probably to cancel it). We can safely
  2984. * ignore the boosting request, as the idle CPU runs this code
  2985. * with interrupts disabled and will complete the lock
  2986. * protected section without being interrupted. So there is no
  2987. * real need to boost.
  2988. */
  2989. if (unlikely(p == rq->idle)) {
  2990. WARN_ON(p != rq->curr);
  2991. WARN_ON(p->pi_blocked_on);
  2992. goto out_unlock;
  2993. }
  2994. trace_sched_pi_setprio(p, prio);
  2995. oldprio = p->prio;
  2996. prev_class = p->sched_class;
  2997. on_rq = p->on_rq;
  2998. running = task_current(rq, p);
  2999. if (on_rq)
  3000. dequeue_task(rq, p, 0);
  3001. if (running)
  3002. p->sched_class->put_prev_task(rq, p);
  3003. if (rt_prio(prio))
  3004. p->sched_class = &rt_sched_class;
  3005. else
  3006. p->sched_class = &fair_sched_class;
  3007. p->prio = prio;
  3008. if (running)
  3009. p->sched_class->set_curr_task(rq);
  3010. if (on_rq)
  3011. enqueue_task(rq, p, oldprio < prio ? ENQUEUE_HEAD : 0);
  3012. check_class_changed(rq, p, prev_class, oldprio);
  3013. out_unlock:
  3014. __task_rq_unlock(rq);
  3015. }
  3016. #endif
  3017. void set_user_nice(struct task_struct *p, long nice)
  3018. {
  3019. int old_prio, delta, on_rq;
  3020. unsigned long flags;
  3021. struct rq *rq;
  3022. if (TASK_NICE(p) == nice || nice < -20 || nice > 19)
  3023. return;
  3024. /*
  3025. * We have to be careful, if called from sys_setpriority(),
  3026. * the task might be in the middle of scheduling on another CPU.
  3027. */
  3028. rq = task_rq_lock(p, &flags);
  3029. /*
  3030. * The RT priorities are set via sched_setscheduler(), but we still
  3031. * allow the 'normal' nice value to be set - but as expected
  3032. * it wont have any effect on scheduling until the task is
  3033. * SCHED_FIFO/SCHED_RR:
  3034. */
  3035. if (task_has_rt_policy(p)) {
  3036. p->static_prio = NICE_TO_PRIO(nice);
  3037. goto out_unlock;
  3038. }
  3039. on_rq = p->on_rq;
  3040. if (on_rq)
  3041. dequeue_task(rq, p, 0);
  3042. p->static_prio = NICE_TO_PRIO(nice);
  3043. set_load_weight(p);
  3044. old_prio = p->prio;
  3045. p->prio = effective_prio(p);
  3046. delta = p->prio - old_prio;
  3047. if (on_rq) {
  3048. enqueue_task(rq, p, 0);
  3049. /*
  3050. * If the task increased its priority or is running and
  3051. * lowered its priority, then reschedule its CPU:
  3052. */
  3053. if (delta < 0 || (delta > 0 && task_running(rq, p)))
  3054. resched_task(rq->curr);
  3055. }
  3056. out_unlock:
  3057. task_rq_unlock(rq, p, &flags);
  3058. }
  3059. EXPORT_SYMBOL(set_user_nice);
  3060. /*
  3061. * can_nice - check if a task can reduce its nice value
  3062. * @p: task
  3063. * @nice: nice value
  3064. */
  3065. int can_nice(const struct task_struct *p, const int nice)
  3066. {
  3067. /* convert nice value [19,-20] to rlimit style value [1,40] */
  3068. int nice_rlim = 20 - nice;
  3069. return (nice_rlim <= task_rlimit(p, RLIMIT_NICE) ||
  3070. capable(CAP_SYS_NICE));
  3071. }
  3072. #ifdef __ARCH_WANT_SYS_NICE
  3073. /*
  3074. * sys_nice - change the priority of the current process.
  3075. * @increment: priority increment
  3076. *
  3077. * sys_setpriority is a more generic, but much slower function that
  3078. * does similar things.
  3079. */
  3080. SYSCALL_DEFINE1(nice, int, increment)
  3081. {
  3082. long nice, retval;
  3083. /*
  3084. * Setpriority might change our priority at the same moment.
  3085. * We don't have to worry. Conceptually one call occurs first
  3086. * and we have a single winner.
  3087. */
  3088. if (increment < -40)
  3089. increment = -40;
  3090. if (increment > 40)
  3091. increment = 40;
  3092. nice = TASK_NICE(current) + increment;
  3093. if (nice < -20)
  3094. nice = -20;
  3095. if (nice > 19)
  3096. nice = 19;
  3097. if (increment < 0 && !can_nice(current, nice))
  3098. return -EPERM;
  3099. retval = security_task_setnice(current, nice);
  3100. if (retval)
  3101. return retval;
  3102. set_user_nice(current, nice);
  3103. return 0;
  3104. }
  3105. #endif
  3106. /**
  3107. * task_prio - return the priority value of a given task.
  3108. * @p: the task in question.
  3109. *
  3110. * This is the priority value as seen by users in /proc.
  3111. * RT tasks are offset by -200. Normal tasks are centered
  3112. * around 0, value goes from -16 to +15.
  3113. */
  3114. int task_prio(const struct task_struct *p)
  3115. {
  3116. return p->prio - MAX_RT_PRIO;
  3117. }
  3118. /**
  3119. * task_nice - return the nice value of a given task.
  3120. * @p: the task in question.
  3121. */
  3122. int task_nice(const struct task_struct *p)
  3123. {
  3124. return TASK_NICE(p);
  3125. }
  3126. EXPORT_SYMBOL(task_nice);
  3127. /**
  3128. * idle_cpu - is a given cpu idle currently?
  3129. * @cpu: the processor in question.
  3130. */
  3131. int idle_cpu(int cpu)
  3132. {
  3133. struct rq *rq = cpu_rq(cpu);
  3134. if (rq->curr != rq->idle)
  3135. return 0;
  3136. if (rq->nr_running)
  3137. return 0;
  3138. #ifdef CONFIG_SMP
  3139. if (!llist_empty(&rq->wake_list))
  3140. return 0;
  3141. #endif
  3142. return 1;
  3143. }
  3144. /**
  3145. * idle_task - return the idle task for a given cpu.
  3146. * @cpu: the processor in question.
  3147. */
  3148. struct task_struct *idle_task(int cpu)
  3149. {
  3150. return cpu_rq(cpu)->idle;
  3151. }
  3152. /**
  3153. * find_process_by_pid - find a process with a matching PID value.
  3154. * @pid: the pid in question.
  3155. */
  3156. static struct task_struct *find_process_by_pid(pid_t pid)
  3157. {
  3158. return pid ? find_task_by_vpid(pid) : current;
  3159. }
  3160. /* Actually do priority change: must hold rq lock. */
  3161. static void
  3162. __setscheduler(struct rq *rq, struct task_struct *p, int policy, int prio)
  3163. {
  3164. p->policy = policy;
  3165. p->rt_priority = prio;
  3166. p->normal_prio = normal_prio(p);
  3167. /* we are holding p->pi_lock already */
  3168. p->prio = rt_mutex_getprio(p);
  3169. if (rt_prio(p->prio))
  3170. p->sched_class = &rt_sched_class;
  3171. else
  3172. p->sched_class = &fair_sched_class;
  3173. set_load_weight(p);
  3174. }
  3175. /*
  3176. * check the target process has a UID that matches the current process's
  3177. */
  3178. static bool check_same_owner(struct task_struct *p)
  3179. {
  3180. const struct cred *cred = current_cred(), *pcred;
  3181. bool match;
  3182. rcu_read_lock();
  3183. pcred = __task_cred(p);
  3184. match = (uid_eq(cred->euid, pcred->euid) ||
  3185. uid_eq(cred->euid, pcred->uid));
  3186. rcu_read_unlock();
  3187. return match;
  3188. }
  3189. static int __sched_setscheduler(struct task_struct *p, int policy,
  3190. const struct sched_param *param, bool user)
  3191. {
  3192. int retval, oldprio, oldpolicy = -1, on_rq, running;
  3193. unsigned long flags;
  3194. const struct sched_class *prev_class;
  3195. struct rq *rq;
  3196. int reset_on_fork;
  3197. /* may grab non-irq protected spin_locks */
  3198. BUG_ON(in_interrupt());
  3199. recheck:
  3200. /* double check policy once rq lock held */
  3201. if (policy < 0) {
  3202. reset_on_fork = p->sched_reset_on_fork;
  3203. policy = oldpolicy = p->policy;
  3204. } else {
  3205. reset_on_fork = !!(policy & SCHED_RESET_ON_FORK);
  3206. policy &= ~SCHED_RESET_ON_FORK;
  3207. if (policy != SCHED_FIFO && policy != SCHED_RR &&
  3208. policy != SCHED_NORMAL && policy != SCHED_BATCH &&
  3209. policy != SCHED_IDLE)
  3210. return -EINVAL;
  3211. }
  3212. /*
  3213. * Valid priorities for SCHED_FIFO and SCHED_RR are
  3214. * 1..MAX_USER_RT_PRIO-1, valid priority for SCHED_NORMAL,
  3215. * SCHED_BATCH and SCHED_IDLE is 0.
  3216. */
  3217. if (param->sched_priority < 0 ||
  3218. (p->mm && param->sched_priority > MAX_USER_RT_PRIO-1) ||
  3219. (!p->mm && param->sched_priority > MAX_RT_PRIO-1))
  3220. return -EINVAL;
  3221. if (rt_policy(policy) != (param->sched_priority != 0))
  3222. return -EINVAL;
  3223. /*
  3224. * Allow unprivileged RT tasks to decrease priority:
  3225. */
  3226. if (user && !capable(CAP_SYS_NICE)) {
  3227. if (rt_policy(policy)) {
  3228. unsigned long rlim_rtprio =
  3229. task_rlimit(p, RLIMIT_RTPRIO);
  3230. /* can't set/change the rt policy */
  3231. if (policy != p->policy && !rlim_rtprio)
  3232. return -EPERM;
  3233. /* can't increase priority */
  3234. if (param->sched_priority > p->rt_priority &&
  3235. param->sched_priority > rlim_rtprio)
  3236. return -EPERM;
  3237. }
  3238. /*
  3239. * Treat SCHED_IDLE as nice 20. Only allow a switch to
  3240. * SCHED_NORMAL if the RLIMIT_NICE would normally permit it.
  3241. */
  3242. if (p->policy == SCHED_IDLE && policy != SCHED_IDLE) {
  3243. if (!can_nice(p, TASK_NICE(p)))
  3244. return -EPERM;
  3245. }
  3246. /* can't change other user's priorities */
  3247. if (!check_same_owner(p))
  3248. return -EPERM;
  3249. /* Normal users shall not reset the sched_reset_on_fork flag */
  3250. if (p->sched_reset_on_fork && !reset_on_fork)
  3251. return -EPERM;
  3252. }
  3253. if (user) {
  3254. retval = security_task_setscheduler(p);
  3255. if (retval)
  3256. return retval;
  3257. }
  3258. /*
  3259. * make sure no PI-waiters arrive (or leave) while we are
  3260. * changing the priority of the task:
  3261. *
  3262. * To be able to change p->policy safely, the appropriate
  3263. * runqueue lock must be held.
  3264. */
  3265. rq = task_rq_lock(p, &flags);
  3266. /*
  3267. * Changing the policy of the stop threads its a very bad idea
  3268. */
  3269. if (p == rq->stop) {
  3270. task_rq_unlock(rq, p, &flags);
  3271. return -EINVAL;
  3272. }
  3273. /*
  3274. * If not changing anything there's no need to proceed further:
  3275. */
  3276. if (unlikely(policy == p->policy && (!rt_policy(policy) ||
  3277. param->sched_priority == p->rt_priority))) {
  3278. task_rq_unlock(rq, p, &flags);
  3279. return 0;
  3280. }
  3281. #ifdef CONFIG_RT_GROUP_SCHED
  3282. if (user) {
  3283. /*
  3284. * Do not allow realtime tasks into groups that have no runtime
  3285. * assigned.
  3286. */
  3287. if (rt_bandwidth_enabled() && rt_policy(policy) &&
  3288. task_group(p)->rt_bandwidth.rt_runtime == 0 &&
  3289. !task_group_is_autogroup(task_group(p))) {
  3290. task_rq_unlock(rq, p, &flags);
  3291. return -EPERM;
  3292. }
  3293. }
  3294. #endif
  3295. /* recheck policy now with rq lock held */
  3296. if (unlikely(oldpolicy != -1 && oldpolicy != p->policy)) {
  3297. policy = oldpolicy = -1;
  3298. task_rq_unlock(rq, p, &flags);
  3299. goto recheck;
  3300. }
  3301. on_rq = p->on_rq;
  3302. running = task_current(rq, p);
  3303. if (on_rq)
  3304. dequeue_task(rq, p, 0);
  3305. if (running)
  3306. p->sched_class->put_prev_task(rq, p);
  3307. p->sched_reset_on_fork = reset_on_fork;
  3308. oldprio = p->prio;
  3309. prev_class = p->sched_class;
  3310. __setscheduler(rq, p, policy, param->sched_priority);
  3311. if (running)
  3312. p->sched_class->set_curr_task(rq);
  3313. if (on_rq)
  3314. enqueue_task(rq, p, 0);
  3315. check_class_changed(rq, p, prev_class, oldprio);
  3316. task_rq_unlock(rq, p, &flags);
  3317. rt_mutex_adjust_pi(p);
  3318. return 0;
  3319. }
  3320. /**
  3321. * sched_setscheduler - change the scheduling policy and/or RT priority of a thread.
  3322. * @p: the task in question.
  3323. * @policy: new policy.
  3324. * @param: structure containing the new RT priority.
  3325. *
  3326. * NOTE that the task may be already dead.
  3327. */
  3328. int sched_setscheduler(struct task_struct *p, int policy,
  3329. const struct sched_param *param)
  3330. {
  3331. return __sched_setscheduler(p, policy, param, true);
  3332. }
  3333. EXPORT_SYMBOL_GPL(sched_setscheduler);
  3334. /**
  3335. * sched_setscheduler_nocheck - change the scheduling policy and/or RT priority of a thread from kernelspace.
  3336. * @p: the task in question.
  3337. * @policy: new policy.
  3338. * @param: structure containing the new RT priority.
  3339. *
  3340. * Just like sched_setscheduler, only don't bother checking if the
  3341. * current context has permission. For example, this is needed in
  3342. * stop_machine(): we create temporary high priority worker threads,
  3343. * but our caller might not have that capability.
  3344. */
  3345. int sched_setscheduler_nocheck(struct task_struct *p, int policy,
  3346. const struct sched_param *param)
  3347. {
  3348. return __sched_setscheduler(p, policy, param, false);
  3349. }
  3350. static int
  3351. do_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
  3352. {
  3353. struct sched_param lparam;
  3354. struct task_struct *p;
  3355. int retval;
  3356. if (!param || pid < 0)
  3357. return -EINVAL;
  3358. if (copy_from_user(&lparam, param, sizeof(struct sched_param)))
  3359. return -EFAULT;
  3360. rcu_read_lock();
  3361. retval = -ESRCH;
  3362. p = find_process_by_pid(pid);
  3363. if (p != NULL)
  3364. retval = sched_setscheduler(p, policy, &lparam);
  3365. rcu_read_unlock();
  3366. return retval;
  3367. }
  3368. /**
  3369. * sys_sched_setscheduler - set/change the scheduler policy and RT priority
  3370. * @pid: the pid in question.
  3371. * @policy: new policy.
  3372. * @param: structure containing the new RT priority.
  3373. */
  3374. SYSCALL_DEFINE3(sched_setscheduler, pid_t, pid, int, policy,
  3375. struct sched_param __user *, param)
  3376. {
  3377. /* negative values for policy are not valid */
  3378. if (policy < 0)
  3379. return -EINVAL;
  3380. return do_sched_setscheduler(pid, policy, param);
  3381. }
  3382. /**
  3383. * sys_sched_setparam - set/change the RT priority of a thread
  3384. * @pid: the pid in question.
  3385. * @param: structure containing the new RT priority.
  3386. */
  3387. SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)
  3388. {
  3389. return do_sched_setscheduler(pid, -1, param);
  3390. }
  3391. /**
  3392. * sys_sched_getscheduler - get the policy (scheduling class) of a thread
  3393. * @pid: the pid in question.
  3394. */
  3395. SYSCALL_DEFINE1(sched_getscheduler, pid_t, pid)
  3396. {
  3397. struct task_struct *p;
  3398. int retval;
  3399. if (pid < 0)
  3400. return -EINVAL;
  3401. retval = -ESRCH;
  3402. rcu_read_lock();
  3403. p = find_process_by_pid(pid);
  3404. if (p) {
  3405. retval = security_task_getscheduler(p);
  3406. if (!retval)
  3407. retval = p->policy
  3408. | (p->sched_reset_on_fork ? SCHED_RESET_ON_FORK : 0);
  3409. }
  3410. rcu_read_unlock();
  3411. return retval;
  3412. }
  3413. /**
  3414. * sys_sched_getparam - get the RT priority of a thread
  3415. * @pid: the pid in question.
  3416. * @param: structure containing the RT priority.
  3417. */
  3418. SYSCALL_DEFINE2(sched_getparam, pid_t, pid, struct sched_param __user *, param)
  3419. {
  3420. struct sched_param lp;
  3421. struct task_struct *p;
  3422. int retval;
  3423. if (!param || pid < 0)
  3424. return -EINVAL;
  3425. rcu_read_lock();
  3426. p = find_process_by_pid(pid);
  3427. retval = -ESRCH;
  3428. if (!p)
  3429. goto out_unlock;
  3430. retval = security_task_getscheduler(p);
  3431. if (retval)
  3432. goto out_unlock;
  3433. lp.sched_priority = p->rt_priority;
  3434. rcu_read_unlock();
  3435. /*
  3436. * This one might sleep, we cannot do it with a spinlock held ...
  3437. */
  3438. retval = copy_to_user(param, &lp, sizeof(*param)) ? -EFAULT : 0;
  3439. return retval;
  3440. out_unlock:
  3441. rcu_read_unlock();
  3442. return retval;
  3443. }
  3444. long sched_setaffinity(pid_t pid, const struct cpumask *in_mask)
  3445. {
  3446. cpumask_var_t cpus_allowed, new_mask;
  3447. struct task_struct *p;
  3448. int retval;
  3449. get_online_cpus();
  3450. rcu_read_lock();
  3451. p = find_process_by_pid(pid);
  3452. if (!p) {
  3453. rcu_read_unlock();
  3454. put_online_cpus();
  3455. return -ESRCH;
  3456. }
  3457. /* Prevent p going away */
  3458. get_task_struct(p);
  3459. rcu_read_unlock();
  3460. if (!alloc_cpumask_var(&cpus_allowed, GFP_KERNEL)) {
  3461. retval = -ENOMEM;
  3462. goto out_put_task;
  3463. }
  3464. if (!alloc_cpumask_var(&new_mask, GFP_KERNEL)) {
  3465. retval = -ENOMEM;
  3466. goto out_free_cpus_allowed;
  3467. }
  3468. retval = -EPERM;
  3469. if (!check_same_owner(p) && !ns_capable(task_user_ns(p), CAP_SYS_NICE))
  3470. goto out_unlock;
  3471. retval = security_task_setscheduler(p);
  3472. if (retval)
  3473. goto out_unlock;
  3474. cpuset_cpus_allowed(p, cpus_allowed);
  3475. cpumask_and(new_mask, in_mask, cpus_allowed);
  3476. again:
  3477. retval = set_cpus_allowed_ptr(p, new_mask);
  3478. if (!retval) {
  3479. cpuset_cpus_allowed(p, cpus_allowed);
  3480. if (!cpumask_subset(new_mask, cpus_allowed)) {
  3481. /*
  3482. * We must have raced with a concurrent cpuset
  3483. * update. Just reset the cpus_allowed to the
  3484. * cpuset's cpus_allowed
  3485. */
  3486. cpumask_copy(new_mask, cpus_allowed);
  3487. goto again;
  3488. }
  3489. }
  3490. out_unlock:
  3491. free_cpumask_var(new_mask);
  3492. out_free_cpus_allowed:
  3493. free_cpumask_var(cpus_allowed);
  3494. out_put_task:
  3495. put_task_struct(p);
  3496. put_online_cpus();
  3497. return retval;
  3498. }
  3499. static int get_user_cpu_mask(unsigned long __user *user_mask_ptr, unsigned len,
  3500. struct cpumask *new_mask)
  3501. {
  3502. if (len < cpumask_size())
  3503. cpumask_clear(new_mask);
  3504. else if (len > cpumask_size())
  3505. len = cpumask_size();
  3506. return copy_from_user(new_mask, user_mask_ptr, len) ? -EFAULT : 0;
  3507. }
  3508. /**
  3509. * sys_sched_setaffinity - set the cpu affinity of a process
  3510. * @pid: pid of the process
  3511. * @len: length in bytes of the bitmask pointed to by user_mask_ptr
  3512. * @user_mask_ptr: user-space pointer to the new cpu mask
  3513. */
  3514. SYSCALL_DEFINE3(sched_setaffinity, pid_t, pid, unsigned int, len,
  3515. unsigned long __user *, user_mask_ptr)
  3516. {
  3517. cpumask_var_t new_mask;
  3518. int retval;
  3519. if (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
  3520. return -ENOMEM;
  3521. retval = get_user_cpu_mask(user_mask_ptr, len, new_mask);
  3522. if (retval == 0)
  3523. retval = sched_setaffinity(pid, new_mask);
  3524. free_cpumask_var(new_mask);
  3525. return retval;
  3526. }
  3527. long sched_getaffinity(pid_t pid, struct cpumask *mask)
  3528. {
  3529. struct task_struct *p;
  3530. unsigned long flags;
  3531. int retval;
  3532. get_online_cpus();
  3533. rcu_read_lock();
  3534. retval = -ESRCH;
  3535. p = find_process_by_pid(pid);
  3536. if (!p)
  3537. goto out_unlock;
  3538. retval = security_task_getscheduler(p);
  3539. if (retval)
  3540. goto out_unlock;
  3541. raw_spin_lock_irqsave(&p->pi_lock, flags);
  3542. cpumask_and(mask, &p->cpus_allowed, cpu_online_mask);
  3543. raw_spin_unlock_irqrestore(&p->pi_lock, flags);
  3544. out_unlock:
  3545. rcu_read_unlock();
  3546. put_online_cpus();
  3547. return retval;
  3548. }
  3549. /**
  3550. * sys_sched_getaffinity - get the cpu affinity of a process
  3551. * @pid: pid of the process
  3552. * @len: length in bytes of the bitmask pointed to by user_mask_ptr
  3553. * @user_mask_ptr: user-space pointer to hold the current cpu mask
  3554. */
  3555. SYSCALL_DEFINE3(sched_getaffinity, pid_t, pid, unsigned int, len,
  3556. unsigned long __user *, user_mask_ptr)
  3557. {
  3558. int ret;
  3559. cpumask_var_t mask;
  3560. if ((len * BITS_PER_BYTE) < nr_cpu_ids)
  3561. return -EINVAL;
  3562. if (len & (sizeof(unsigned long)-1))
  3563. return -EINVAL;
  3564. if (!alloc_cpumask_var(&mask, GFP_KERNEL))
  3565. return -ENOMEM;
  3566. ret = sched_getaffinity(pid, mask);
  3567. if (ret == 0) {
  3568. size_t retlen = min_t(size_t, len, cpumask_size());
  3569. if (copy_to_user(user_mask_ptr, mask, retlen))
  3570. ret = -EFAULT;
  3571. else
  3572. ret = retlen;
  3573. }
  3574. free_cpumask_var(mask);
  3575. return ret;
  3576. }
  3577. /**
  3578. * sys_sched_yield - yield the current processor to other threads.
  3579. *
  3580. * This function yields the current CPU to other tasks. If there are no
  3581. * other threads running on this CPU then this function will return.
  3582. */
  3583. SYSCALL_DEFINE0(sched_yield)
  3584. {
  3585. struct rq *rq = this_rq_lock();
  3586. schedstat_inc(rq, yld_count);
  3587. current->sched_class->yield_task(rq);
  3588. /*
  3589. * Since we are going to call schedule() anyway, there's
  3590. * no need to preempt or enable interrupts:
  3591. */
  3592. __release(rq->lock);
  3593. spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
  3594. do_raw_spin_unlock(&rq->lock);
  3595. sched_preempt_enable_no_resched();
  3596. schedule();
  3597. return 0;
  3598. }
  3599. static inline int should_resched(void)
  3600. {
  3601. return need_resched() && !(preempt_count() & PREEMPT_ACTIVE);
  3602. }
  3603. static void __cond_resched(void)
  3604. {
  3605. add_preempt_count(PREEMPT_ACTIVE);
  3606. __schedule();
  3607. sub_preempt_count(PREEMPT_ACTIVE);
  3608. }
  3609. int __sched _cond_resched(void)
  3610. {
  3611. if (should_resched()) {
  3612. __cond_resched();
  3613. return 1;
  3614. }
  3615. return 0;
  3616. }
  3617. EXPORT_SYMBOL(_cond_resched);
  3618. /*
  3619. * __cond_resched_lock() - if a reschedule is pending, drop the given lock,
  3620. * call schedule, and on return reacquire the lock.
  3621. *
  3622. * This works OK both with and without CONFIG_PREEMPT. We do strange low-level
  3623. * operations here to prevent schedule() from being called twice (once via
  3624. * spin_unlock(), once by hand).
  3625. */
  3626. int __cond_resched_lock(spinlock_t *lock)
  3627. {
  3628. int resched = should_resched();
  3629. int ret = 0;
  3630. lockdep_assert_held(lock);
  3631. if (spin_needbreak(lock) || resched) {
  3632. spin_unlock(lock);
  3633. if (resched)
  3634. __cond_resched();
  3635. else
  3636. cpu_relax();
  3637. ret = 1;
  3638. spin_lock(lock);
  3639. }
  3640. return ret;
  3641. }
  3642. EXPORT_SYMBOL(__cond_resched_lock);
  3643. int __sched __cond_resched_softirq(void)
  3644. {
  3645. BUG_ON(!in_softirq());
  3646. if (should_resched()) {
  3647. local_bh_enable();
  3648. __cond_resched();
  3649. local_bh_disable();
  3650. return 1;
  3651. }
  3652. return 0;
  3653. }
  3654. EXPORT_SYMBOL(__cond_resched_softirq);
  3655. /**
  3656. * yield - yield the current processor to other threads.
  3657. *
  3658. * Do not ever use this function, there's a 99% chance you're doing it wrong.
  3659. *
  3660. * The scheduler is at all times free to pick the calling task as the most
  3661. * eligible task to run, if removing the yield() call from your code breaks
  3662. * it, its already broken.
  3663. *
  3664. * Typical broken usage is:
  3665. *
  3666. * while (!event)
  3667. * yield();
  3668. *
  3669. * where one assumes that yield() will let 'the other' process run that will
  3670. * make event true. If the current task is a SCHED_FIFO task that will never
  3671. * happen. Never use yield() as a progress guarantee!!
  3672. *
  3673. * If you want to use yield() to wait for something, use wait_event().
  3674. * If you want to use yield() to be 'nice' for others, use cond_resched().
  3675. * If you still want to use yield(), do not!
  3676. */
  3677. void __sched yield(void)
  3678. {
  3679. set_current_state(TASK_RUNNING);
  3680. sys_sched_yield();
  3681. }
  3682. EXPORT_SYMBOL(yield);
  3683. /**
  3684. * yield_to - yield the current processor to another thread in
  3685. * your thread group, or accelerate that thread toward the
  3686. * processor it's on.
  3687. * @p: target task
  3688. * @preempt: whether task preemption is allowed or not
  3689. *
  3690. * It's the caller's job to ensure that the target task struct
  3691. * can't go away on us before we can do any checks.
  3692. *
  3693. * Returns true if we indeed boosted the target task.
  3694. */
  3695. bool __sched yield_to(struct task_struct *p, bool preempt)
  3696. {
  3697. struct task_struct *curr = current;
  3698. struct rq *rq, *p_rq;
  3699. unsigned long flags;
  3700. bool yielded = 0;
  3701. local_irq_save(flags);
  3702. rq = this_rq();
  3703. again:
  3704. p_rq = task_rq(p);
  3705. double_rq_lock(rq, p_rq);
  3706. while (task_rq(p) != p_rq) {
  3707. double_rq_unlock(rq, p_rq);
  3708. goto again;
  3709. }
  3710. if (!curr->sched_class->yield_to_task)
  3711. goto out;
  3712. if (curr->sched_class != p->sched_class)
  3713. goto out;
  3714. if (task_running(p_rq, p) || p->state)
  3715. goto out;
  3716. yielded = curr->sched_class->yield_to_task(rq, p, preempt);
  3717. if (yielded) {
  3718. schedstat_inc(rq, yld_count);
  3719. /*
  3720. * Make p's CPU reschedule; pick_next_entity takes care of
  3721. * fairness.
  3722. */
  3723. if (preempt && rq != p_rq)
  3724. resched_task(p_rq->curr);
  3725. }
  3726. out:
  3727. double_rq_unlock(rq, p_rq);
  3728. local_irq_restore(flags);
  3729. if (yielded)
  3730. schedule();
  3731. return yielded;
  3732. }
  3733. EXPORT_SYMBOL_GPL(yield_to);
  3734. /*
  3735. * This task is about to go to sleep on IO. Increment rq->nr_iowait so
  3736. * that process accounting knows that this is a task in IO wait state.
  3737. */
  3738. void __sched io_schedule(void)
  3739. {
  3740. struct rq *rq = raw_rq();
  3741. delayacct_blkio_start();
  3742. atomic_inc(&rq->nr_iowait);
  3743. blk_flush_plug(current);
  3744. current->in_iowait = 1;
  3745. schedule();
  3746. current->in_iowait = 0;
  3747. atomic_dec(&rq->nr_iowait);
  3748. delayacct_blkio_end();
  3749. }
  3750. EXPORT_SYMBOL(io_schedule);
  3751. long __sched io_schedule_timeout(long timeout)
  3752. {
  3753. struct rq *rq = raw_rq();
  3754. long ret;
  3755. delayacct_blkio_start();
  3756. atomic_inc(&rq->nr_iowait);
  3757. blk_flush_plug(current);
  3758. current->in_iowait = 1;
  3759. ret = schedule_timeout(timeout);
  3760. current->in_iowait = 0;
  3761. atomic_dec(&rq->nr_iowait);
  3762. delayacct_blkio_end();
  3763. return ret;
  3764. }
  3765. /**
  3766. * sys_sched_get_priority_max - return maximum RT priority.
  3767. * @policy: scheduling class.
  3768. *
  3769. * this syscall returns the maximum rt_priority that can be used
  3770. * by a given scheduling class.
  3771. */
  3772. SYSCALL_DEFINE1(sched_get_priority_max, int, policy)
  3773. {
  3774. int ret = -EINVAL;
  3775. switch (policy) {
  3776. case SCHED_FIFO:
  3777. case SCHED_RR:
  3778. ret = MAX_USER_RT_PRIO-1;
  3779. break;
  3780. case SCHED_NORMAL:
  3781. case SCHED_BATCH:
  3782. case SCHED_IDLE:
  3783. ret = 0;
  3784. break;
  3785. }
  3786. return ret;
  3787. }
  3788. /**
  3789. * sys_sched_get_priority_min - return minimum RT priority.
  3790. * @policy: scheduling class.
  3791. *
  3792. * this syscall returns the minimum rt_priority that can be used
  3793. * by a given scheduling class.
  3794. */
  3795. SYSCALL_DEFINE1(sched_get_priority_min, int, policy)
  3796. {
  3797. int ret = -EINVAL;
  3798. switch (policy) {
  3799. case SCHED_FIFO:
  3800. case SCHED_RR:
  3801. ret = 1;
  3802. break;
  3803. case SCHED_NORMAL:
  3804. case SCHED_BATCH:
  3805. case SCHED_IDLE:
  3806. ret = 0;
  3807. }
  3808. return ret;
  3809. }
  3810. /**
  3811. * sys_sched_rr_get_interval - return the default timeslice of a process.
  3812. * @pid: pid of the process.
  3813. * @interval: userspace pointer to the timeslice value.
  3814. *
  3815. * this syscall writes the default timeslice value of a given process
  3816. * into the user-space timespec buffer. A value of '0' means infinity.
  3817. */
  3818. SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
  3819. struct timespec __user *, interval)
  3820. {
  3821. struct task_struct *p;
  3822. unsigned int time_slice;
  3823. unsigned long flags;
  3824. struct rq *rq;
  3825. int retval;
  3826. struct timespec t;
  3827. if (pid < 0)
  3828. return -EINVAL;
  3829. retval = -ESRCH;
  3830. rcu_read_lock();
  3831. p = find_process_by_pid(pid);
  3832. if (!p)
  3833. goto out_unlock;
  3834. retval = security_task_getscheduler(p);
  3835. if (retval)
  3836. goto out_unlock;
  3837. rq = task_rq_lock(p, &flags);
  3838. time_slice = p->sched_class->get_rr_interval(rq, p);
  3839. task_rq_unlock(rq, p, &flags);
  3840. rcu_read_unlock();
  3841. jiffies_to_timespec(time_slice, &t);
  3842. retval = copy_to_user(interval, &t, sizeof(t)) ? -EFAULT : 0;
  3843. return retval;
  3844. out_unlock:
  3845. rcu_read_unlock();
  3846. return retval;
  3847. }
  3848. static const char stat_nam[] = TASK_STATE_TO_CHAR_STR;
  3849. void sched_show_task(struct task_struct *p)
  3850. {
  3851. unsigned long free = 0;
  3852. int ppid;
  3853. unsigned state;
  3854. state = p->state ? __ffs(p->state) + 1 : 0;
  3855. printk(KERN_INFO "%-15.15s %c", p->comm,
  3856. state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
  3857. #if BITS_PER_LONG == 32
  3858. if (state == TASK_RUNNING)
  3859. printk(KERN_CONT " running ");
  3860. else
  3861. printk(KERN_CONT " %08lx ", thread_saved_pc(p));
  3862. #else
  3863. if (state == TASK_RUNNING)
  3864. printk(KERN_CONT " running task ");
  3865. else
  3866. printk(KERN_CONT " %016lx ", thread_saved_pc(p));
  3867. #endif
  3868. #ifdef CONFIG_DEBUG_STACK_USAGE
  3869. free = stack_not_used(p);
  3870. #endif
  3871. rcu_read_lock();
  3872. ppid = task_pid_nr(rcu_dereference(p->real_parent));
  3873. rcu_read_unlock();
  3874. printk(KERN_CONT "%5lu %5d %6d 0x%08lx\n", free,
  3875. task_pid_nr(p), ppid,
  3876. (unsigned long)task_thread_info(p)->flags);
  3877. show_stack(p, NULL);
  3878. }
  3879. void show_state_filter(unsigned long state_filter)
  3880. {
  3881. struct task_struct *g, *p;
  3882. #if BITS_PER_LONG == 32
  3883. printk(KERN_INFO
  3884. " task PC stack pid father\n");
  3885. #else
  3886. printk(KERN_INFO
  3887. " task PC stack pid father\n");
  3888. #endif
  3889. rcu_read_lock();
  3890. do_each_thread(g, p) {
  3891. /*
  3892. * reset the NMI-timeout, listing all files on a slow
  3893. * console might take a lot of time:
  3894. */
  3895. touch_nmi_watchdog();
  3896. if (!state_filter || (p->state & state_filter))
  3897. sched_show_task(p);
  3898. } while_each_thread(g, p);
  3899. touch_all_softlockup_watchdogs();
  3900. #ifdef CONFIG_SCHED_DEBUG
  3901. sysrq_sched_debug_show();
  3902. #endif
  3903. rcu_read_unlock();
  3904. /*
  3905. * Only show locks if all tasks are dumped:
  3906. */
  3907. if (!state_filter)
  3908. debug_show_all_locks();
  3909. }
  3910. void __cpuinit init_idle_bootup_task(struct task_struct *idle)
  3911. {
  3912. idle->sched_class = &idle_sched_class;
  3913. }
  3914. /**
  3915. * init_idle - set up an idle thread for a given CPU
  3916. * @idle: task in question
  3917. * @cpu: cpu the idle task belongs to
  3918. *
  3919. * NOTE: this function does not set the idle thread's NEED_RESCHED
  3920. * flag, to make booting more robust.
  3921. */
  3922. void __cpuinit init_idle(struct task_struct *idle, int cpu)
  3923. {
  3924. struct rq *rq = cpu_rq(cpu);
  3925. unsigned long flags;
  3926. raw_spin_lock_irqsave(&rq->lock, flags);
  3927. __sched_fork(idle);
  3928. idle->state = TASK_RUNNING;
  3929. idle->se.exec_start = sched_clock();
  3930. do_set_cpus_allowed(idle, cpumask_of(cpu));
  3931. /*
  3932. * We're having a chicken and egg problem, even though we are
  3933. * holding rq->lock, the cpu isn't yet set to this cpu so the
  3934. * lockdep check in task_group() will fail.
  3935. *
  3936. * Similar case to sched_fork(). / Alternatively we could
  3937. * use task_rq_lock() here and obtain the other rq->lock.
  3938. *
  3939. * Silence PROVE_RCU
  3940. */
  3941. rcu_read_lock();
  3942. __set_task_cpu(idle, cpu);
  3943. rcu_read_unlock();
  3944. rq->curr = rq->idle = idle;
  3945. #if defined(CONFIG_SMP)
  3946. idle->on_cpu = 1;
  3947. #endif
  3948. raw_spin_unlock_irqrestore(&rq->lock, flags);
  3949. /* Set the preempt count _outside_ the spinlocks! */
  3950. task_thread_info(idle)->preempt_count = 0;
  3951. /*
  3952. * The idle tasks have their own, simple scheduling class:
  3953. */
  3954. idle->sched_class = &idle_sched_class;
  3955. ftrace_graph_init_idle_task(idle, cpu);
  3956. #if defined(CONFIG_SMP)
  3957. sprintf(idle->comm, "%s/%d", INIT_TASK_COMM, cpu);
  3958. #endif
  3959. }
  3960. #ifdef CONFIG_SMP
  3961. void do_set_cpus_allowed(struct task_struct *p, const struct cpumask *new_mask)
  3962. {
  3963. if (p->sched_class && p->sched_class->set_cpus_allowed)
  3964. p->sched_class->set_cpus_allowed(p, new_mask);
  3965. cpumask_copy(&p->cpus_allowed, new_mask);
  3966. p->nr_cpus_allowed = cpumask_weight(new_mask);
  3967. }
  3968. /*
  3969. * This is how migration works:
  3970. *
  3971. * 1) we invoke migration_cpu_stop() on the target CPU using
  3972. * stop_one_cpu().
  3973. * 2) stopper starts to run (implicitly forcing the migrated thread
  3974. * off the CPU)
  3975. * 3) it checks whether the migrated task is still in the wrong runqueue.
  3976. * 4) if it's in the wrong runqueue then the migration thread removes
  3977. * it and puts it into the right queue.
  3978. * 5) stopper completes and stop_one_cpu() returns and the migration
  3979. * is done.
  3980. */
  3981. /*
  3982. * Change a given task's CPU affinity. Migrate the thread to a
  3983. * proper CPU and schedule it away if the CPU it's executing on
  3984. * is removed from the allowed bitmask.
  3985. *
  3986. * NOTE: the caller must have a valid reference to the task, the
  3987. * task must not exit() & deallocate itself prematurely. The
  3988. * call is not atomic; no spinlocks may be held.
  3989. */
  3990. int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)
  3991. {
  3992. unsigned long flags;
  3993. struct rq *rq;
  3994. unsigned int dest_cpu;
  3995. int ret = 0;
  3996. rq = task_rq_lock(p, &flags);
  3997. if (cpumask_equal(&p->cpus_allowed, new_mask))
  3998. goto out;
  3999. if (!cpumask_intersects(new_mask, cpu_active_mask)) {
  4000. ret = -EINVAL;
  4001. goto out;
  4002. }
  4003. if (unlikely((p->flags & PF_THREAD_BOUND) && p != current)) {
  4004. ret = -EINVAL;
  4005. goto out;
  4006. }
  4007. do_set_cpus_allowed(p, new_mask);
  4008. /* Can the task run on the task's current CPU? If so, we're done */
  4009. if (cpumask_test_cpu(task_cpu(p), new_mask))
  4010. goto out;
  4011. dest_cpu = cpumask_any_and(cpu_active_mask, new_mask);
  4012. if (p->on_rq) {
  4013. struct migration_arg arg = { p, dest_cpu };
  4014. /* Need help from migration thread: drop lock and wait. */
  4015. task_rq_unlock(rq, p, &flags);
  4016. stop_one_cpu(cpu_of(rq), migration_cpu_stop, &arg);
  4017. tlb_migrate_finish(p->mm);
  4018. return 0;
  4019. }
  4020. out:
  4021. task_rq_unlock(rq, p, &flags);
  4022. return ret;
  4023. }
  4024. EXPORT_SYMBOL_GPL(set_cpus_allowed_ptr);
  4025. /*
  4026. * Move (not current) task off this cpu, onto dest cpu. We're doing
  4027. * this because either it can't run here any more (set_cpus_allowed()
  4028. * away from this CPU, or CPU going down), or because we're
  4029. * attempting to rebalance this task on exec (sched_exec).
  4030. *
  4031. * So we race with normal scheduler movements, but that's OK, as long
  4032. * as the task is no longer on this CPU.
  4033. *
  4034. * Returns non-zero if task was successfully migrated.
  4035. */
  4036. static int __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
  4037. {
  4038. struct rq *rq_dest, *rq_src;
  4039. int ret = 0;
  4040. if (unlikely(!cpu_active(dest_cpu)))
  4041. return ret;
  4042. rq_src = cpu_rq(src_cpu);
  4043. rq_dest = cpu_rq(dest_cpu);
  4044. raw_spin_lock(&p->pi_lock);
  4045. double_rq_lock(rq_src, rq_dest);
  4046. /* Already moved. */
  4047. if (task_cpu(p) != src_cpu)
  4048. goto done;
  4049. /* Affinity changed (again). */
  4050. if (!cpumask_test_cpu(dest_cpu, tsk_cpus_allowed(p)))
  4051. goto fail;
  4052. /*
  4053. * If we're not on a rq, the next wake-up will ensure we're
  4054. * placed properly.
  4055. */
  4056. if (p->on_rq) {
  4057. dequeue_task(rq_src, p, 0);
  4058. set_task_cpu(p, dest_cpu);
  4059. enqueue_task(rq_dest, p, 0);
  4060. check_preempt_curr(rq_dest, p, 0);
  4061. }
  4062. done:
  4063. ret = 1;
  4064. fail:
  4065. double_rq_unlock(rq_src, rq_dest);
  4066. raw_spin_unlock(&p->pi_lock);
  4067. return ret;
  4068. }
  4069. /*
  4070. * migration_cpu_stop - this will be executed by a highprio stopper thread
  4071. * and performs thread migration by bumping thread off CPU then
  4072. * 'pushing' onto another runqueue.
  4073. */
  4074. static int migration_cpu_stop(void *data)
  4075. {
  4076. struct migration_arg *arg = data;
  4077. /*
  4078. * The original target cpu might have gone down and we might
  4079. * be on another cpu but it doesn't matter.
  4080. */
  4081. local_irq_disable();
  4082. __migrate_task(arg->task, raw_smp_processor_id(), arg->dest_cpu);
  4083. local_irq_enable();
  4084. return 0;
  4085. }
  4086. #ifdef CONFIG_HOTPLUG_CPU
  4087. /*
  4088. * Ensures that the idle task is using init_mm right before its cpu goes
  4089. * offline.
  4090. */
  4091. void idle_task_exit(void)
  4092. {
  4093. struct mm_struct *mm = current->active_mm;
  4094. BUG_ON(cpu_online(smp_processor_id()));
  4095. if (mm != &init_mm)
  4096. switch_mm(mm, &init_mm, current);
  4097. mmdrop(mm);
  4098. }
  4099. /*
  4100. * Since this CPU is going 'away' for a while, fold any nr_active delta
  4101. * we might have. Assumes we're called after migrate_tasks() so that the
  4102. * nr_active count is stable.
  4103. *
  4104. * Also see the comment "Global load-average calculations".
  4105. */
  4106. static void calc_load_migrate(struct rq *rq)
  4107. {
  4108. long delta = calc_load_fold_active(rq);
  4109. if (delta)
  4110. atomic_long_add(delta, &calc_load_tasks);
  4111. }
  4112. /*
  4113. * Migrate all tasks from the rq, sleeping tasks will be migrated by
  4114. * try_to_wake_up()->select_task_rq().
  4115. *
  4116. * Called with rq->lock held even though we'er in stop_machine() and
  4117. * there's no concurrency possible, we hold the required locks anyway
  4118. * because of lock validation efforts.
  4119. */
  4120. static void migrate_tasks(unsigned int dead_cpu)
  4121. {
  4122. struct rq *rq = cpu_rq(dead_cpu);
  4123. struct task_struct *next, *stop = rq->stop;
  4124. int dest_cpu;
  4125. /*
  4126. * Fudge the rq selection such that the below task selection loop
  4127. * doesn't get stuck on the currently eligible stop task.
  4128. *
  4129. * We're currently inside stop_machine() and the rq is either stuck
  4130. * in the stop_machine_cpu_stop() loop, or we're executing this code,
  4131. * either way we should never end up calling schedule() until we're
  4132. * done here.
  4133. */
  4134. rq->stop = NULL;
  4135. for ( ; ; ) {
  4136. /*
  4137. * There's this thread running, bail when that's the only
  4138. * remaining thread.
  4139. */
  4140. if (rq->nr_running == 1)
  4141. break;
  4142. next = pick_next_task(rq);
  4143. BUG_ON(!next);
  4144. next->sched_class->put_prev_task(rq, next);
  4145. /* Find suitable destination for @next, with force if needed. */
  4146. dest_cpu = select_fallback_rq(dead_cpu, next);
  4147. raw_spin_unlock(&rq->lock);
  4148. __migrate_task(next, dead_cpu, dest_cpu);
  4149. raw_spin_lock(&rq->lock);
  4150. }
  4151. rq->stop = stop;
  4152. }
  4153. #endif /* CONFIG_HOTPLUG_CPU */
  4154. #if defined(CONFIG_SCHED_DEBUG) && defined(CONFIG_SYSCTL)
  4155. static struct ctl_table sd_ctl_dir[] = {
  4156. {
  4157. .procname = "sched_domain",
  4158. .mode = 0555,
  4159. },
  4160. {}
  4161. };
  4162. static struct ctl_table sd_ctl_root[] = {
  4163. {
  4164. .procname = "kernel",
  4165. .mode = 0555,
  4166. .child = sd_ctl_dir,
  4167. },
  4168. {}
  4169. };
  4170. static struct ctl_table *sd_alloc_ctl_entry(int n)
  4171. {
  4172. struct ctl_table *entry =
  4173. kcalloc(n, sizeof(struct ctl_table), GFP_KERNEL);
  4174. return entry;
  4175. }
  4176. static void sd_free_ctl_entry(struct ctl_table **tablep)
  4177. {
  4178. struct ctl_table *entry;
  4179. /*
  4180. * In the intermediate directories, both the child directory and
  4181. * procname are dynamically allocated and could fail but the mode
  4182. * will always be set. In the lowest directory the names are
  4183. * static strings and all have proc handlers.
  4184. */
  4185. for (entry = *tablep; entry->mode; entry++) {
  4186. if (entry->child)
  4187. sd_free_ctl_entry(&entry->child);
  4188. if (entry->proc_handler == NULL)
  4189. kfree(entry->procname);
  4190. }
  4191. kfree(*tablep);
  4192. *tablep = NULL;
  4193. }
  4194. static int min_load_idx = 0;
  4195. static int max_load_idx = CPU_LOAD_IDX_MAX;
  4196. static void
  4197. set_table_entry(struct ctl_table *entry,
  4198. const char *procname, void *data, int maxlen,
  4199. umode_t mode, proc_handler *proc_handler,
  4200. bool load_idx)
  4201. {
  4202. entry->procname = procname;
  4203. entry->data = data;
  4204. entry->maxlen = maxlen;
  4205. entry->mode = mode;
  4206. entry->proc_handler = proc_handler;
  4207. if (load_idx) {
  4208. entry->extra1 = &min_load_idx;
  4209. entry->extra2 = &max_load_idx;
  4210. }
  4211. }
  4212. static struct ctl_table *
  4213. sd_alloc_ctl_domain_table(struct sched_domain *sd)
  4214. {
  4215. struct ctl_table *table = sd_alloc_ctl_entry(13);
  4216. if (table == NULL)
  4217. return NULL;
  4218. set_table_entry(&table[0], "min_interval", &sd->min_interval,
  4219. sizeof(long), 0644, proc_doulongvec_minmax, false);
  4220. set_table_entry(&table[1], "max_interval", &sd->max_interval,
  4221. sizeof(long), 0644, proc_doulongvec_minmax, false);
  4222. set_table_entry(&table[2], "busy_idx", &sd->busy_idx,
  4223. sizeof(int), 0644, proc_dointvec_minmax, true);
  4224. set_table_entry(&table[3], "idle_idx", &sd->idle_idx,
  4225. sizeof(int), 0644, proc_dointvec_minmax, true);
  4226. set_table_entry(&table[4], "newidle_idx", &sd->newidle_idx,
  4227. sizeof(int), 0644, proc_dointvec_minmax, true);
  4228. set_table_entry(&table[5], "wake_idx", &sd->wake_idx,
  4229. sizeof(int), 0644, proc_dointvec_minmax, true);
  4230. set_table_entry(&table[6], "forkexec_idx", &sd->forkexec_idx,
  4231. sizeof(int), 0644, proc_dointvec_minmax, true);
  4232. set_table_entry(&table[7], "busy_factor", &sd->busy_factor,
  4233. sizeof(int), 0644, proc_dointvec_minmax, false);
  4234. set_table_entry(&table[8], "imbalance_pct", &sd->imbalance_pct,
  4235. sizeof(int), 0644, proc_dointvec_minmax, false);
  4236. set_table_entry(&table[9], "cache_nice_tries",
  4237. &sd->cache_nice_tries,
  4238. sizeof(int), 0644, proc_dointvec_minmax, false);
  4239. set_table_entry(&table[10], "flags", &sd->flags,
  4240. sizeof(int), 0644, proc_dointvec_minmax, false);
  4241. set_table_entry(&table[11], "name", sd->name,
  4242. CORENAME_MAX_SIZE, 0444, proc_dostring, false);
  4243. /* &table[12] is terminator */
  4244. return table;
  4245. }
  4246. static ctl_table *sd_alloc_ctl_cpu_table(int cpu)
  4247. {
  4248. struct ctl_table *entry, *table;
  4249. struct sched_domain *sd;
  4250. int domain_num = 0, i;
  4251. char buf[32];
  4252. for_each_domain(cpu, sd)
  4253. domain_num++;
  4254. entry = table = sd_alloc_ctl_entry(domain_num + 1);
  4255. if (table == NULL)
  4256. return NULL;
  4257. i = 0;
  4258. for_each_domain(cpu, sd) {
  4259. snprintf(buf, 32, "domain%d", i);
  4260. entry->procname = kstrdup(buf, GFP_KERNEL);
  4261. entry->mode = 0555;
  4262. entry->child = sd_alloc_ctl_domain_table(sd);
  4263. entry++;
  4264. i++;
  4265. }
  4266. return table;
  4267. }
  4268. static struct ctl_table_header *sd_sysctl_header;
  4269. static void register_sched_domain_sysctl(void)
  4270. {
  4271. int i, cpu_num = num_possible_cpus();
  4272. struct ctl_table *entry = sd_alloc_ctl_entry(cpu_num + 1);
  4273. char buf[32];
  4274. WARN_ON(sd_ctl_dir[0].child);
  4275. sd_ctl_dir[0].child = entry;
  4276. if (entry == NULL)
  4277. return;
  4278. for_each_possible_cpu(i) {
  4279. snprintf(buf, 32, "cpu%d", i);
  4280. entry->procname = kstrdup(buf, GFP_KERNEL);
  4281. entry->mode = 0555;
  4282. entry->child = sd_alloc_ctl_cpu_table(i);
  4283. entry++;
  4284. }
  4285. WARN_ON(sd_sysctl_header);
  4286. sd_sysctl_header = register_sysctl_table(sd_ctl_root);
  4287. }
  4288. /* may be called multiple times per register */
  4289. static void unregister_sched_domain_sysctl(void)
  4290. {
  4291. if (sd_sysctl_header)
  4292. unregister_sysctl_table(sd_sysctl_header);
  4293. sd_sysctl_header = NULL;
  4294. if (sd_ctl_dir[0].child)
  4295. sd_free_ctl_entry(&sd_ctl_dir[0].child);
  4296. }
  4297. #else
  4298. static void register_sched_domain_sysctl(void)
  4299. {
  4300. }
  4301. static void unregister_sched_domain_sysctl(void)
  4302. {
  4303. }
  4304. #endif
  4305. static void set_rq_online(struct rq *rq)
  4306. {
  4307. if (!rq->online) {
  4308. const struct sched_class *class;
  4309. cpumask_set_cpu(rq->cpu, rq->rd->online);
  4310. rq->online = 1;
  4311. for_each_class(class) {
  4312. if (class->rq_online)
  4313. class->rq_online(rq);
  4314. }
  4315. }
  4316. }
  4317. static void set_rq_offline(struct rq *rq)
  4318. {
  4319. if (rq->online) {
  4320. const struct sched_class *class;
  4321. for_each_class(class) {
  4322. if (class->rq_offline)
  4323. class->rq_offline(rq);
  4324. }
  4325. cpumask_clear_cpu(rq->cpu, rq->rd->online);
  4326. rq->online = 0;
  4327. }
  4328. }
  4329. /*
  4330. * migration_call - callback that gets triggered when a CPU is added.
  4331. * Here we can start up the necessary migration thread for the new CPU.
  4332. */
  4333. static int __cpuinit
  4334. migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
  4335. {
  4336. int cpu = (long)hcpu;
  4337. unsigned long flags;
  4338. struct rq *rq = cpu_rq(cpu);
  4339. switch (action & ~CPU_TASKS_FROZEN) {
  4340. case CPU_UP_PREPARE:
  4341. rq->calc_load_update = calc_load_update;
  4342. break;
  4343. case CPU_ONLINE:
  4344. /* Update our root-domain */
  4345. raw_spin_lock_irqsave(&rq->lock, flags);
  4346. if (rq->rd) {
  4347. BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
  4348. set_rq_online(rq);
  4349. }
  4350. raw_spin_unlock_irqrestore(&rq->lock, flags);
  4351. break;
  4352. #ifdef CONFIG_HOTPLUG_CPU
  4353. case CPU_DYING:
  4354. sched_ttwu_pending();
  4355. /* Update our root-domain */
  4356. raw_spin_lock_irqsave(&rq->lock, flags);
  4357. if (rq->rd) {
  4358. BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
  4359. set_rq_offline(rq);
  4360. }
  4361. migrate_tasks(cpu);
  4362. BUG_ON(rq->nr_running != 1); /* the migration thread */
  4363. raw_spin_unlock_irqrestore(&rq->lock, flags);
  4364. break;
  4365. case CPU_DEAD:
  4366. calc_load_migrate(rq);
  4367. break;
  4368. #endif
  4369. }
  4370. update_max_interval();
  4371. return NOTIFY_OK;
  4372. }
  4373. /*
  4374. * Register at high priority so that task migration (migrate_all_tasks)
  4375. * happens before everything else. This has to be lower priority than
  4376. * the notifier in the perf_event subsystem, though.
  4377. */
  4378. static struct notifier_block __cpuinitdata migration_notifier = {
  4379. .notifier_call = migration_call,
  4380. .priority = CPU_PRI_MIGRATION,
  4381. };
  4382. static int __cpuinit sched_cpu_active(struct notifier_block *nfb,
  4383. unsigned long action, void *hcpu)
  4384. {
  4385. switch (action & ~CPU_TASKS_FROZEN) {
  4386. case CPU_STARTING:
  4387. case CPU_DOWN_FAILED:
  4388. set_cpu_active((long)hcpu, true);
  4389. return NOTIFY_OK;
  4390. default:
  4391. return NOTIFY_DONE;
  4392. }
  4393. }
  4394. static int __cpuinit sched_cpu_inactive(struct notifier_block *nfb,
  4395. unsigned long action, void *hcpu)
  4396. {
  4397. switch (action & ~CPU_TASKS_FROZEN) {
  4398. case CPU_DOWN_PREPARE:
  4399. set_cpu_active((long)hcpu, false);
  4400. return NOTIFY_OK;
  4401. default:
  4402. return NOTIFY_DONE;
  4403. }
  4404. }
  4405. static int __init migration_init(void)
  4406. {
  4407. void *cpu = (void *)(long)smp_processor_id();
  4408. int err;
  4409. /* Initialize migration for the boot CPU */
  4410. err = migration_call(&migration_notifier, CPU_UP_PREPARE, cpu);
  4411. BUG_ON(err == NOTIFY_BAD);
  4412. migration_call(&migration_notifier, CPU_ONLINE, cpu);
  4413. register_cpu_notifier(&migration_notifier);
  4414. /* Register cpu active notifiers */
  4415. cpu_notifier(sched_cpu_active, CPU_PRI_SCHED_ACTIVE);
  4416. cpu_notifier(sched_cpu_inactive, CPU_PRI_SCHED_INACTIVE);
  4417. return 0;
  4418. }
  4419. early_initcall(migration_init);
  4420. #endif
  4421. #ifdef CONFIG_SMP
  4422. static cpumask_var_t sched_domains_tmpmask; /* sched_domains_mutex */
  4423. #ifdef CONFIG_SCHED_DEBUG
  4424. static __read_mostly int sched_debug_enabled;
  4425. static int __init sched_debug_setup(char *str)
  4426. {
  4427. sched_debug_enabled = 1;
  4428. return 0;
  4429. }
  4430. early_param("sched_debug", sched_debug_setup);
  4431. static inline bool sched_debug(void)
  4432. {
  4433. return sched_debug_enabled;
  4434. }
  4435. static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
  4436. struct cpumask *groupmask)
  4437. {
  4438. struct sched_group *group = sd->groups;
  4439. char str[256];
  4440. cpulist_scnprintf(str, sizeof(str), sched_domain_span(sd));
  4441. cpumask_clear(groupmask);
  4442. printk(KERN_DEBUG "%*s domain %d: ", level, "", level);
  4443. if (!(sd->flags & SD_LOAD_BALANCE)) {
  4444. printk("does not load-balance\n");
  4445. if (sd->parent)
  4446. printk(KERN_ERR "ERROR: !SD_LOAD_BALANCE domain"
  4447. " has parent");
  4448. return -1;
  4449. }
  4450. printk(KERN_CONT "span %s level %s\n", str, sd->name);
  4451. if (!cpumask_test_cpu(cpu, sched_domain_span(sd))) {
  4452. printk(KERN_ERR "ERROR: domain->span does not contain "
  4453. "CPU%d\n", cpu);
  4454. }
  4455. if (!cpumask_test_cpu(cpu, sched_group_cpus(group))) {
  4456. printk(KERN_ERR "ERROR: domain->groups does not contain"
  4457. " CPU%d\n", cpu);
  4458. }
  4459. printk(KERN_DEBUG "%*s groups:", level + 1, "");
  4460. do {
  4461. if (!group) {
  4462. printk("\n");
  4463. printk(KERN_ERR "ERROR: group is NULL\n");
  4464. break;
  4465. }
  4466. /*
  4467. * Even though we initialize ->power to something semi-sane,
  4468. * we leave power_orig unset. This allows us to detect if
  4469. * domain iteration is still funny without causing /0 traps.
  4470. */
  4471. if (!group->sgp->power_orig) {
  4472. printk(KERN_CONT "\n");
  4473. printk(KERN_ERR "ERROR: domain->cpu_power not "
  4474. "set\n");
  4475. break;
  4476. }
  4477. if (!cpumask_weight(sched_group_cpus(group))) {
  4478. printk(KERN_CONT "\n");
  4479. printk(KERN_ERR "ERROR: empty group\n");
  4480. break;
  4481. }
  4482. if (!(sd->flags & SD_OVERLAP) &&
  4483. cpumask_intersects(groupmask, sched_group_cpus(group))) {
  4484. printk(KERN_CONT "\n");
  4485. printk(KERN_ERR "ERROR: repeated CPUs\n");
  4486. break;
  4487. }
  4488. cpumask_or(groupmask, groupmask, sched_group_cpus(group));
  4489. cpulist_scnprintf(str, sizeof(str), sched_group_cpus(group));
  4490. printk(KERN_CONT " %s", str);
  4491. if (group->sgp->power != SCHED_POWER_SCALE) {
  4492. printk(KERN_CONT " (cpu_power = %d)",
  4493. group->sgp->power);
  4494. }
  4495. group = group->next;
  4496. } while (group != sd->groups);
  4497. printk(KERN_CONT "\n");
  4498. if (!cpumask_equal(sched_domain_span(sd), groupmask))
  4499. printk(KERN_ERR "ERROR: groups don't span domain->span\n");
  4500. if (sd->parent &&
  4501. !cpumask_subset(groupmask, sched_domain_span(sd->parent)))
  4502. printk(KERN_ERR "ERROR: parent span is not a superset "
  4503. "of domain->span\n");
  4504. return 0;
  4505. }
  4506. static void sched_domain_debug(struct sched_domain *sd, int cpu)
  4507. {
  4508. int level = 0;
  4509. if (!sched_debug_enabled)
  4510. return;
  4511. if (!sd) {
  4512. printk(KERN_DEBUG "CPU%d attaching NULL sched-domain.\n", cpu);
  4513. return;
  4514. }
  4515. printk(KERN_DEBUG "CPU%d attaching sched-domain:\n", cpu);
  4516. for (;;) {
  4517. if (sched_domain_debug_one(sd, cpu, level, sched_domains_tmpmask))
  4518. break;
  4519. level++;
  4520. sd = sd->parent;
  4521. if (!sd)
  4522. break;
  4523. }
  4524. }
  4525. #else /* !CONFIG_SCHED_DEBUG */
  4526. # define sched_domain_debug(sd, cpu) do { } while (0)
  4527. static inline bool sched_debug(void)
  4528. {
  4529. return false;
  4530. }
  4531. #endif /* CONFIG_SCHED_DEBUG */
  4532. static int sd_degenerate(struct sched_domain *sd)
  4533. {
  4534. if (cpumask_weight(sched_domain_span(sd)) == 1)
  4535. return 1;
  4536. /* Following flags need at least 2 groups */
  4537. if (sd->flags & (SD_LOAD_BALANCE |
  4538. SD_BALANCE_NEWIDLE |
  4539. SD_BALANCE_FORK |
  4540. SD_BALANCE_EXEC |
  4541. SD_SHARE_CPUPOWER |
  4542. SD_SHARE_PKG_RESOURCES)) {
  4543. if (sd->groups != sd->groups->next)
  4544. return 0;
  4545. }
  4546. /* Following flags don't use groups */
  4547. if (sd->flags & (SD_WAKE_AFFINE))
  4548. return 0;
  4549. return 1;
  4550. }
  4551. static int
  4552. sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)
  4553. {
  4554. unsigned long cflags = sd->flags, pflags = parent->flags;
  4555. if (sd_degenerate(parent))
  4556. return 1;
  4557. if (!cpumask_equal(sched_domain_span(sd), sched_domain_span(parent)))
  4558. return 0;
  4559. /* Flags needing groups don't count if only 1 group in parent */
  4560. if (parent->groups == parent->groups->next) {
  4561. pflags &= ~(SD_LOAD_BALANCE |
  4562. SD_BALANCE_NEWIDLE |
  4563. SD_BALANCE_FORK |
  4564. SD_BALANCE_EXEC |
  4565. SD_SHARE_CPUPOWER |
  4566. SD_SHARE_PKG_RESOURCES);
  4567. if (nr_node_ids == 1)
  4568. pflags &= ~SD_SERIALIZE;
  4569. }
  4570. if (~cflags & pflags)
  4571. return 0;
  4572. return 1;
  4573. }
  4574. static void free_rootdomain(struct rcu_head *rcu)
  4575. {
  4576. struct root_domain *rd = container_of(rcu, struct root_domain, rcu);
  4577. cpupri_cleanup(&rd->cpupri);
  4578. free_cpumask_var(rd->rto_mask);
  4579. free_cpumask_var(rd->online);
  4580. free_cpumask_var(rd->span);
  4581. kfree(rd);
  4582. }
  4583. static void rq_attach_root(struct rq *rq, struct root_domain *rd)
  4584. {
  4585. struct root_domain *old_rd = NULL;
  4586. unsigned long flags;
  4587. raw_spin_lock_irqsave(&rq->lock, flags);
  4588. if (rq->rd) {
  4589. old_rd = rq->rd;
  4590. if (cpumask_test_cpu(rq->cpu, old_rd->online))
  4591. set_rq_offline(rq);
  4592. cpumask_clear_cpu(rq->cpu, old_rd->span);
  4593. /*
  4594. * If we dont want to free the old_rt yet then
  4595. * set old_rd to NULL to skip the freeing later
  4596. * in this function:
  4597. */
  4598. if (!atomic_dec_and_test(&old_rd->refcount))
  4599. old_rd = NULL;
  4600. }
  4601. atomic_inc(&rd->refcount);
  4602. rq->rd = rd;
  4603. cpumask_set_cpu(rq->cpu, rd->span);
  4604. if (cpumask_test_cpu(rq->cpu, cpu_active_mask))
  4605. set_rq_online(rq);
  4606. raw_spin_unlock_irqrestore(&rq->lock, flags);
  4607. if (old_rd)
  4608. call_rcu_sched(&old_rd->rcu, free_rootdomain);
  4609. }
  4610. static int init_rootdomain(struct root_domain *rd)
  4611. {
  4612. memset(rd, 0, sizeof(*rd));
  4613. if (!alloc_cpumask_var(&rd->span, GFP_KERNEL))
  4614. goto out;
  4615. if (!alloc_cpumask_var(&rd->online, GFP_KERNEL))
  4616. goto free_span;
  4617. if (!alloc_cpumask_var(&rd->rto_mask, GFP_KERNEL))
  4618. goto free_online;
  4619. if (cpupri_init(&rd->cpupri) != 0)
  4620. goto free_rto_mask;
  4621. return 0;
  4622. free_rto_mask:
  4623. free_cpumask_var(rd->rto_mask);
  4624. free_online:
  4625. free_cpumask_var(rd->online);
  4626. free_span:
  4627. free_cpumask_var(rd->span);
  4628. out:
  4629. return -ENOMEM;
  4630. }
  4631. /*
  4632. * By default the system creates a single root-domain with all cpus as
  4633. * members (mimicking the global state we have today).
  4634. */
  4635. struct root_domain def_root_domain;
  4636. static void init_defrootdomain(void)
  4637. {
  4638. init_rootdomain(&def_root_domain);
  4639. atomic_set(&def_root_domain.refcount, 1);
  4640. }
  4641. static struct root_domain *alloc_rootdomain(void)
  4642. {
  4643. struct root_domain *rd;
  4644. rd = kmalloc(sizeof(*rd), GFP_KERNEL);
  4645. if (!rd)
  4646. return NULL;
  4647. if (init_rootdomain(rd) != 0) {
  4648. kfree(rd);
  4649. return NULL;
  4650. }
  4651. return rd;
  4652. }
  4653. static void free_sched_groups(struct sched_group *sg, int free_sgp)
  4654. {
  4655. struct sched_group *tmp, *first;
  4656. if (!sg)
  4657. return;
  4658. first = sg;
  4659. do {
  4660. tmp = sg->next;
  4661. if (free_sgp && atomic_dec_and_test(&sg->sgp->ref))
  4662. kfree(sg->sgp);
  4663. kfree(sg);
  4664. sg = tmp;
  4665. } while (sg != first);
  4666. }
  4667. static void free_sched_domain(struct rcu_head *rcu)
  4668. {
  4669. struct sched_domain *sd = container_of(rcu, struct sched_domain, rcu);
  4670. /*
  4671. * If its an overlapping domain it has private groups, iterate and
  4672. * nuke them all.
  4673. */
  4674. if (sd->flags & SD_OVERLAP) {
  4675. free_sched_groups(sd->groups, 1);
  4676. } else if (atomic_dec_and_test(&sd->groups->ref)) {
  4677. kfree(sd->groups->sgp);
  4678. kfree(sd->groups);
  4679. }
  4680. kfree(sd);
  4681. }
  4682. static void destroy_sched_domain(struct sched_domain *sd, int cpu)
  4683. {
  4684. call_rcu(&sd->rcu, free_sched_domain);
  4685. }
  4686. static void destroy_sched_domains(struct sched_domain *sd, int cpu)
  4687. {
  4688. for (; sd; sd = sd->parent)
  4689. destroy_sched_domain(sd, cpu);
  4690. }
  4691. /*
  4692. * Keep a special pointer to the highest sched_domain that has
  4693. * SD_SHARE_PKG_RESOURCE set (Last Level Cache Domain) for this
  4694. * allows us to avoid some pointer chasing select_idle_sibling().
  4695. *
  4696. * Also keep a unique ID per domain (we use the first cpu number in
  4697. * the cpumask of the domain), this allows us to quickly tell if
  4698. * two cpus are in the same cache domain, see cpus_share_cache().
  4699. */
  4700. DEFINE_PER_CPU(struct sched_domain *, sd_llc);
  4701. DEFINE_PER_CPU(int, sd_llc_id);
  4702. static void update_top_cache_domain(int cpu)
  4703. {
  4704. struct sched_domain *sd;
  4705. int id = cpu;
  4706. sd = highest_flag_domain(cpu, SD_SHARE_PKG_RESOURCES);
  4707. if (sd)
  4708. id = cpumask_first(sched_domain_span(sd));
  4709. rcu_assign_pointer(per_cpu(sd_llc, cpu), sd);
  4710. per_cpu(sd_llc_id, cpu) = id;
  4711. }
  4712. /*
  4713. * Attach the domain 'sd' to 'cpu' as its base domain. Callers must
  4714. * hold the hotplug lock.
  4715. */
  4716. static void
  4717. cpu_attach_domain(struct sched_domain *sd, struct root_domain *rd, int cpu)
  4718. {
  4719. struct rq *rq = cpu_rq(cpu);
  4720. struct sched_domain *tmp;
  4721. /* Remove the sched domains which do not contribute to scheduling. */
  4722. for (tmp = sd; tmp; ) {
  4723. struct sched_domain *parent = tmp->parent;
  4724. if (!parent)
  4725. break;
  4726. if (sd_parent_degenerate(tmp, parent)) {
  4727. tmp->parent = parent->parent;
  4728. if (parent->parent)
  4729. parent->parent->child = tmp;
  4730. destroy_sched_domain(parent, cpu);
  4731. } else
  4732. tmp = tmp->parent;
  4733. }
  4734. if (sd && sd_degenerate(sd)) {
  4735. tmp = sd;
  4736. sd = sd->parent;
  4737. destroy_sched_domain(tmp, cpu);
  4738. if (sd)
  4739. sd->child = NULL;
  4740. }
  4741. sched_domain_debug(sd, cpu);
  4742. rq_attach_root(rq, rd);
  4743. tmp = rq->sd;
  4744. rcu_assign_pointer(rq->sd, sd);
  4745. destroy_sched_domains(tmp, cpu);
  4746. update_top_cache_domain(cpu);
  4747. }
  4748. /* cpus with isolated domains */
  4749. static cpumask_var_t cpu_isolated_map;
  4750. /* Setup the mask of cpus configured for isolated domains */
  4751. static int __init isolated_cpu_setup(char *str)
  4752. {
  4753. alloc_bootmem_cpumask_var(&cpu_isolated_map);
  4754. cpulist_parse(str, cpu_isolated_map);
  4755. return 1;
  4756. }
  4757. __setup("isolcpus=", isolated_cpu_setup);
  4758. static const struct cpumask *cpu_cpu_mask(int cpu)
  4759. {
  4760. return cpumask_of_node(cpu_to_node(cpu));
  4761. }
  4762. struct sd_data {
  4763. struct sched_domain **__percpu sd;
  4764. struct sched_group **__percpu sg;
  4765. struct sched_group_power **__percpu sgp;
  4766. };
  4767. struct s_data {
  4768. struct sched_domain ** __percpu sd;
  4769. struct root_domain *rd;
  4770. };
  4771. enum s_alloc {
  4772. sa_rootdomain,
  4773. sa_sd,
  4774. sa_sd_storage,
  4775. sa_none,
  4776. };
  4777. struct sched_domain_topology_level;
  4778. typedef struct sched_domain *(*sched_domain_init_f)(struct sched_domain_topology_level *tl, int cpu);
  4779. typedef const struct cpumask *(*sched_domain_mask_f)(int cpu);
  4780. #define SDTL_OVERLAP 0x01
  4781. struct sched_domain_topology_level {
  4782. sched_domain_init_f init;
  4783. sched_domain_mask_f mask;
  4784. int flags;
  4785. int numa_level;
  4786. struct sd_data data;
  4787. };
  4788. /*
  4789. * Build an iteration mask that can exclude certain CPUs from the upwards
  4790. * domain traversal.
  4791. *
  4792. * Asymmetric node setups can result in situations where the domain tree is of
  4793. * unequal depth, make sure to skip domains that already cover the entire
  4794. * range.
  4795. *
  4796. * In that case build_sched_domains() will have terminated the iteration early
  4797. * and our sibling sd spans will be empty. Domains should always include the
  4798. * cpu they're built on, so check that.
  4799. *
  4800. */
  4801. static void build_group_mask(struct sched_domain *sd, struct sched_group *sg)
  4802. {
  4803. const struct cpumask *span = sched_domain_span(sd);
  4804. struct sd_data *sdd = sd->private;
  4805. struct sched_domain *sibling;
  4806. int i;
  4807. for_each_cpu(i, span) {
  4808. sibling = *per_cpu_ptr(sdd->sd, i);
  4809. if (!cpumask_test_cpu(i, sched_domain_span(sibling)))
  4810. continue;
  4811. cpumask_set_cpu(i, sched_group_mask(sg));
  4812. }
  4813. }
  4814. /*
  4815. * Return the canonical balance cpu for this group, this is the first cpu
  4816. * of this group that's also in the iteration mask.
  4817. */
  4818. int group_balance_cpu(struct sched_group *sg)
  4819. {
  4820. return cpumask_first_and(sched_group_cpus(sg), sched_group_mask(sg));
  4821. }
  4822. static int
  4823. build_overlap_sched_groups(struct sched_domain *sd, int cpu)
  4824. {
  4825. struct sched_group *first = NULL, *last = NULL, *groups = NULL, *sg;
  4826. const struct cpumask *span = sched_domain_span(sd);
  4827. struct cpumask *covered = sched_domains_tmpmask;
  4828. struct sd_data *sdd = sd->private;
  4829. struct sched_domain *child;
  4830. int i;
  4831. cpumask_clear(covered);
  4832. for_each_cpu(i, span) {
  4833. struct cpumask *sg_span;
  4834. if (cpumask_test_cpu(i, covered))
  4835. continue;
  4836. child = *per_cpu_ptr(sdd->sd, i);
  4837. /* See the comment near build_group_mask(). */
  4838. if (!cpumask_test_cpu(i, sched_domain_span(child)))
  4839. continue;
  4840. sg = kzalloc_node(sizeof(struct sched_group) + cpumask_size(),
  4841. GFP_KERNEL, cpu_to_node(cpu));
  4842. if (!sg)
  4843. goto fail;
  4844. sg_span = sched_group_cpus(sg);
  4845. if (child->child) {
  4846. child = child->child;
  4847. cpumask_copy(sg_span, sched_domain_span(child));
  4848. } else
  4849. cpumask_set_cpu(i, sg_span);
  4850. cpumask_or(covered, covered, sg_span);
  4851. sg->sgp = *per_cpu_ptr(sdd->sgp, i);
  4852. if (atomic_inc_return(&sg->sgp->ref) == 1)
  4853. build_group_mask(sd, sg);
  4854. /*
  4855. * Initialize sgp->power such that even if we mess up the
  4856. * domains and no possible iteration will get us here, we won't
  4857. * die on a /0 trap.
  4858. */
  4859. sg->sgp->power = SCHED_POWER_SCALE * cpumask_weight(sg_span);
  4860. /*
  4861. * Make sure the first group of this domain contains the
  4862. * canonical balance cpu. Otherwise the sched_domain iteration
  4863. * breaks. See update_sg_lb_stats().
  4864. */
  4865. if ((!groups && cpumask_test_cpu(cpu, sg_span)) ||
  4866. group_balance_cpu(sg) == cpu)
  4867. groups = sg;
  4868. if (!first)
  4869. first = sg;
  4870. if (last)
  4871. last->next = sg;
  4872. last = sg;
  4873. last->next = first;
  4874. }
  4875. sd->groups = groups;
  4876. return 0;
  4877. fail:
  4878. free_sched_groups(first, 0);
  4879. return -ENOMEM;
  4880. }
  4881. static int get_group(int cpu, struct sd_data *sdd, struct sched_group **sg)
  4882. {
  4883. struct sched_domain *sd = *per_cpu_ptr(sdd->sd, cpu);
  4884. struct sched_domain *child = sd->child;
  4885. if (child)
  4886. cpu = cpumask_first(sched_domain_span(child));
  4887. if (sg) {
  4888. *sg = *per_cpu_ptr(sdd->sg, cpu);
  4889. (*sg)->sgp = *per_cpu_ptr(sdd->sgp, cpu);
  4890. atomic_set(&(*sg)->sgp->ref, 1); /* for claim_allocations */
  4891. }
  4892. return cpu;
  4893. }
  4894. /*
  4895. * build_sched_groups will build a circular linked list of the groups
  4896. * covered by the given span, and will set each group's ->cpumask correctly,
  4897. * and ->cpu_power to 0.
  4898. *
  4899. * Assumes the sched_domain tree is fully constructed
  4900. */
  4901. static int
  4902. build_sched_groups(struct sched_domain *sd, int cpu)
  4903. {
  4904. struct sched_group *first = NULL, *last = NULL;
  4905. struct sd_data *sdd = sd->private;
  4906. const struct cpumask *span = sched_domain_span(sd);
  4907. struct cpumask *covered;
  4908. int i;
  4909. get_group(cpu, sdd, &sd->groups);
  4910. atomic_inc(&sd->groups->ref);
  4911. if (cpu != cpumask_first(sched_domain_span(sd)))
  4912. return 0;
  4913. lockdep_assert_held(&sched_domains_mutex);
  4914. covered = sched_domains_tmpmask;
  4915. cpumask_clear(covered);
  4916. for_each_cpu(i, span) {
  4917. struct sched_group *sg;
  4918. int group = get_group(i, sdd, &sg);
  4919. int j;
  4920. if (cpumask_test_cpu(i, covered))
  4921. continue;
  4922. cpumask_clear(sched_group_cpus(sg));
  4923. sg->sgp->power = 0;
  4924. cpumask_setall(sched_group_mask(sg));
  4925. for_each_cpu(j, span) {
  4926. if (get_group(j, sdd, NULL) != group)
  4927. continue;
  4928. cpumask_set_cpu(j, covered);
  4929. cpumask_set_cpu(j, sched_group_cpus(sg));
  4930. }
  4931. if (!first)
  4932. first = sg;
  4933. if (last)
  4934. last->next = sg;
  4935. last = sg;
  4936. }
  4937. last->next = first;
  4938. return 0;
  4939. }
  4940. /*
  4941. * Initialize sched groups cpu_power.
  4942. *
  4943. * cpu_power indicates the capacity of sched group, which is used while
  4944. * distributing the load between different sched groups in a sched domain.
  4945. * Typically cpu_power for all the groups in a sched domain will be same unless
  4946. * there are asymmetries in the topology. If there are asymmetries, group
  4947. * having more cpu_power will pickup more load compared to the group having
  4948. * less cpu_power.
  4949. */
  4950. static void init_sched_groups_power(int cpu, struct sched_domain *sd)
  4951. {
  4952. struct sched_group *sg = sd->groups;
  4953. WARN_ON(!sd || !sg);
  4954. do {
  4955. sg->group_weight = cpumask_weight(sched_group_cpus(sg));
  4956. sg = sg->next;
  4957. } while (sg != sd->groups);
  4958. if (cpu != group_balance_cpu(sg))
  4959. return;
  4960. update_group_power(sd, cpu);
  4961. atomic_set(&sg->sgp->nr_busy_cpus, sg->group_weight);
  4962. }
  4963. int __weak arch_sd_sibling_asym_packing(void)
  4964. {
  4965. return 0*SD_ASYM_PACKING;
  4966. }
  4967. /*
  4968. * Initializers for schedule domains
  4969. * Non-inlined to reduce accumulated stack pressure in build_sched_domains()
  4970. */
  4971. #ifdef CONFIG_SCHED_DEBUG
  4972. # define SD_INIT_NAME(sd, type) sd->name = #type
  4973. #else
  4974. # define SD_INIT_NAME(sd, type) do { } while (0)
  4975. #endif
  4976. #define SD_INIT_FUNC(type) \
  4977. static noinline struct sched_domain * \
  4978. sd_init_##type(struct sched_domain_topology_level *tl, int cpu) \
  4979. { \
  4980. struct sched_domain *sd = *per_cpu_ptr(tl->data.sd, cpu); \
  4981. *sd = SD_##type##_INIT; \
  4982. SD_INIT_NAME(sd, type); \
  4983. sd->private = &tl->data; \
  4984. return sd; \
  4985. }
  4986. SD_INIT_FUNC(CPU)
  4987. #ifdef CONFIG_SCHED_SMT
  4988. SD_INIT_FUNC(SIBLING)
  4989. #endif
  4990. #ifdef CONFIG_SCHED_MC
  4991. SD_INIT_FUNC(MC)
  4992. #endif
  4993. #ifdef CONFIG_SCHED_BOOK
  4994. SD_INIT_FUNC(BOOK)
  4995. #endif
  4996. static int default_relax_domain_level = -1;
  4997. int sched_domain_level_max;
  4998. static int __init setup_relax_domain_level(char *str)
  4999. {
  5000. if (kstrtoint(str, 0, &default_relax_domain_level))
  5001. pr_warn("Unable to set relax_domain_level\n");
  5002. return 1;
  5003. }
  5004. __setup("relax_domain_level=", setup_relax_domain_level);
  5005. static void set_domain_attribute(struct sched_domain *sd,
  5006. struct sched_domain_attr *attr)
  5007. {
  5008. int request;
  5009. if (!attr || attr->relax_domain_level < 0) {
  5010. if (default_relax_domain_level < 0)
  5011. return;
  5012. else
  5013. request = default_relax_domain_level;
  5014. } else
  5015. request = attr->relax_domain_level;
  5016. if (request < sd->level) {
  5017. /* turn off idle balance on this domain */
  5018. sd->flags &= ~(SD_BALANCE_WAKE|SD_BALANCE_NEWIDLE);
  5019. } else {
  5020. /* turn on idle balance on this domain */
  5021. sd->flags |= (SD_BALANCE_WAKE|SD_BALANCE_NEWIDLE);
  5022. }
  5023. }
  5024. static void __sdt_free(const struct cpumask *cpu_map);
  5025. static int __sdt_alloc(const struct cpumask *cpu_map);
  5026. static void __free_domain_allocs(struct s_data *d, enum s_alloc what,
  5027. const struct cpumask *cpu_map)
  5028. {
  5029. switch (what) {
  5030. case sa_rootdomain:
  5031. if (!atomic_read(&d->rd->refcount))
  5032. free_rootdomain(&d->rd->rcu); /* fall through */
  5033. case sa_sd:
  5034. free_percpu(d->sd); /* fall through */
  5035. case sa_sd_storage:
  5036. __sdt_free(cpu_map); /* fall through */
  5037. case sa_none:
  5038. break;
  5039. }
  5040. }
  5041. static enum s_alloc __visit_domain_allocation_hell(struct s_data *d,
  5042. const struct cpumask *cpu_map)
  5043. {
  5044. memset(d, 0, sizeof(*d));
  5045. if (__sdt_alloc(cpu_map))
  5046. return sa_sd_storage;
  5047. d->sd = alloc_percpu(struct sched_domain *);
  5048. if (!d->sd)
  5049. return sa_sd_storage;
  5050. d->rd = alloc_rootdomain();
  5051. if (!d->rd)
  5052. return sa_sd;
  5053. return sa_rootdomain;
  5054. }
  5055. /*
  5056. * NULL the sd_data elements we've used to build the sched_domain and
  5057. * sched_group structure so that the subsequent __free_domain_allocs()
  5058. * will not free the data we're using.
  5059. */
  5060. static void claim_allocations(int cpu, struct sched_domain *sd)
  5061. {
  5062. struct sd_data *sdd = sd->private;
  5063. WARN_ON_ONCE(*per_cpu_ptr(sdd->sd, cpu) != sd);
  5064. *per_cpu_ptr(sdd->sd, cpu) = NULL;
  5065. if (atomic_read(&(*per_cpu_ptr(sdd->sg, cpu))->ref))
  5066. *per_cpu_ptr(sdd->sg, cpu) = NULL;
  5067. if (atomic_read(&(*per_cpu_ptr(sdd->sgp, cpu))->ref))
  5068. *per_cpu_ptr(sdd->sgp, cpu) = NULL;
  5069. }
  5070. #ifdef CONFIG_SCHED_SMT
  5071. static const struct cpumask *cpu_smt_mask(int cpu)
  5072. {
  5073. return topology_thread_cpumask(cpu);
  5074. }
  5075. #endif
  5076. /*
  5077. * Topology list, bottom-up.
  5078. */
  5079. static struct sched_domain_topology_level default_topology[] = {
  5080. #ifdef CONFIG_SCHED_SMT
  5081. { sd_init_SIBLING, cpu_smt_mask, },
  5082. #endif
  5083. #ifdef CONFIG_SCHED_MC
  5084. { sd_init_MC, cpu_coregroup_mask, },
  5085. #endif
  5086. #ifdef CONFIG_SCHED_BOOK
  5087. { sd_init_BOOK, cpu_book_mask, },
  5088. #endif
  5089. { sd_init_CPU, cpu_cpu_mask, },
  5090. { NULL, },
  5091. };
  5092. static struct sched_domain_topology_level *sched_domain_topology = default_topology;
  5093. #ifdef CONFIG_NUMA
  5094. static int sched_domains_numa_levels;
  5095. static int *sched_domains_numa_distance;
  5096. static struct cpumask ***sched_domains_numa_masks;
  5097. static int sched_domains_curr_level;
  5098. static inline int sd_local_flags(int level)
  5099. {
  5100. if (sched_domains_numa_distance[level] > RECLAIM_DISTANCE)
  5101. return 0;
  5102. return SD_BALANCE_EXEC | SD_BALANCE_FORK | SD_WAKE_AFFINE;
  5103. }
  5104. static struct sched_domain *
  5105. sd_numa_init(struct sched_domain_topology_level *tl, int cpu)
  5106. {
  5107. struct sched_domain *sd = *per_cpu_ptr(tl->data.sd, cpu);
  5108. int level = tl->numa_level;
  5109. int sd_weight = cpumask_weight(
  5110. sched_domains_numa_masks[level][cpu_to_node(cpu)]);
  5111. *sd = (struct sched_domain){
  5112. .min_interval = sd_weight,
  5113. .max_interval = 2*sd_weight,
  5114. .busy_factor = 32,
  5115. .imbalance_pct = 125,
  5116. .cache_nice_tries = 2,
  5117. .busy_idx = 3,
  5118. .idle_idx = 2,
  5119. .newidle_idx = 0,
  5120. .wake_idx = 0,
  5121. .forkexec_idx = 0,
  5122. .flags = 1*SD_LOAD_BALANCE
  5123. | 1*SD_BALANCE_NEWIDLE
  5124. | 0*SD_BALANCE_EXEC
  5125. | 0*SD_BALANCE_FORK
  5126. | 0*SD_BALANCE_WAKE
  5127. | 0*SD_WAKE_AFFINE
  5128. | 0*SD_SHARE_CPUPOWER
  5129. | 0*SD_SHARE_PKG_RESOURCES
  5130. | 1*SD_SERIALIZE
  5131. | 0*SD_PREFER_SIBLING
  5132. | sd_local_flags(level)
  5133. ,
  5134. .last_balance = jiffies,
  5135. .balance_interval = sd_weight,
  5136. };
  5137. SD_INIT_NAME(sd, NUMA);
  5138. sd->private = &tl->data;
  5139. /*
  5140. * Ugly hack to pass state to sd_numa_mask()...
  5141. */
  5142. sched_domains_curr_level = tl->numa_level;
  5143. return sd;
  5144. }
  5145. static const struct cpumask *sd_numa_mask(int cpu)
  5146. {
  5147. return sched_domains_numa_masks[sched_domains_curr_level][cpu_to_node(cpu)];
  5148. }
  5149. static void sched_numa_warn(const char *str)
  5150. {
  5151. static int done = false;
  5152. int i,j;
  5153. if (done)
  5154. return;
  5155. done = true;
  5156. printk(KERN_WARNING "ERROR: %s\n\n", str);
  5157. for (i = 0; i < nr_node_ids; i++) {
  5158. printk(KERN_WARNING " ");
  5159. for (j = 0; j < nr_node_ids; j++)
  5160. printk(KERN_CONT "%02d ", node_distance(i,j));
  5161. printk(KERN_CONT "\n");
  5162. }
  5163. printk(KERN_WARNING "\n");
  5164. }
  5165. static bool find_numa_distance(int distance)
  5166. {
  5167. int i;
  5168. if (distance == node_distance(0, 0))
  5169. return true;
  5170. for (i = 0; i < sched_domains_numa_levels; i++) {
  5171. if (sched_domains_numa_distance[i] == distance)
  5172. return true;
  5173. }
  5174. return false;
  5175. }
  5176. static void sched_init_numa(void)
  5177. {
  5178. int next_distance, curr_distance = node_distance(0, 0);
  5179. struct sched_domain_topology_level *tl;
  5180. int level = 0;
  5181. int i, j, k;
  5182. sched_domains_numa_distance = kzalloc(sizeof(int) * nr_node_ids, GFP_KERNEL);
  5183. if (!sched_domains_numa_distance)
  5184. return;
  5185. /*
  5186. * O(nr_nodes^2) deduplicating selection sort -- in order to find the
  5187. * unique distances in the node_distance() table.
  5188. *
  5189. * Assumes node_distance(0,j) includes all distances in
  5190. * node_distance(i,j) in order to avoid cubic time.
  5191. */
  5192. next_distance = curr_distance;
  5193. for (i = 0; i < nr_node_ids; i++) {
  5194. for (j = 0; j < nr_node_ids; j++) {
  5195. for (k = 0; k < nr_node_ids; k++) {
  5196. int distance = node_distance(i, k);
  5197. if (distance > curr_distance &&
  5198. (distance < next_distance ||
  5199. next_distance == curr_distance))
  5200. next_distance = distance;
  5201. /*
  5202. * While not a strong assumption it would be nice to know
  5203. * about cases where if node A is connected to B, B is not
  5204. * equally connected to A.
  5205. */
  5206. if (sched_debug() && node_distance(k, i) != distance)
  5207. sched_numa_warn("Node-distance not symmetric");
  5208. if (sched_debug() && i && !find_numa_distance(distance))
  5209. sched_numa_warn("Node-0 not representative");
  5210. }
  5211. if (next_distance != curr_distance) {
  5212. sched_domains_numa_distance[level++] = next_distance;
  5213. sched_domains_numa_levels = level;
  5214. curr_distance = next_distance;
  5215. } else break;
  5216. }
  5217. /*
  5218. * In case of sched_debug() we verify the above assumption.
  5219. */
  5220. if (!sched_debug())
  5221. break;
  5222. }
  5223. /*
  5224. * 'level' contains the number of unique distances, excluding the
  5225. * identity distance node_distance(i,i).
  5226. *
  5227. * The sched_domains_nume_distance[] array includes the actual distance
  5228. * numbers.
  5229. */
  5230. /*
  5231. * Here, we should temporarily reset sched_domains_numa_levels to 0.
  5232. * If it fails to allocate memory for array sched_domains_numa_masks[][],
  5233. * the array will contain less then 'level' members. This could be
  5234. * dangerous when we use it to iterate array sched_domains_numa_masks[][]
  5235. * in other functions.
  5236. *
  5237. * We reset it to 'level' at the end of this function.
  5238. */
  5239. sched_domains_numa_levels = 0;
  5240. sched_domains_numa_masks = kzalloc(sizeof(void *) * level, GFP_KERNEL);
  5241. if (!sched_domains_numa_masks)
  5242. return;
  5243. /*
  5244. * Now for each level, construct a mask per node which contains all
  5245. * cpus of nodes that are that many hops away from us.
  5246. */
  5247. for (i = 0; i < level; i++) {
  5248. sched_domains_numa_masks[i] =
  5249. kzalloc(nr_node_ids * sizeof(void *), GFP_KERNEL);
  5250. if (!sched_domains_numa_masks[i])
  5251. return;
  5252. for (j = 0; j < nr_node_ids; j++) {
  5253. struct cpumask *mask = kzalloc(cpumask_size(), GFP_KERNEL);
  5254. if (!mask)
  5255. return;
  5256. sched_domains_numa_masks[i][j] = mask;
  5257. for (k = 0; k < nr_node_ids; k++) {
  5258. if (node_distance(j, k) > sched_domains_numa_distance[i])
  5259. continue;
  5260. cpumask_or(mask, mask, cpumask_of_node(k));
  5261. }
  5262. }
  5263. }
  5264. tl = kzalloc((ARRAY_SIZE(default_topology) + level) *
  5265. sizeof(struct sched_domain_topology_level), GFP_KERNEL);
  5266. if (!tl)
  5267. return;
  5268. /*
  5269. * Copy the default topology bits..
  5270. */
  5271. for (i = 0; default_topology[i].init; i++)
  5272. tl[i] = default_topology[i];
  5273. /*
  5274. * .. and append 'j' levels of NUMA goodness.
  5275. */
  5276. for (j = 0; j < level; i++, j++) {
  5277. tl[i] = (struct sched_domain_topology_level){
  5278. .init = sd_numa_init,
  5279. .mask = sd_numa_mask,
  5280. .flags = SDTL_OVERLAP,
  5281. .numa_level = j,
  5282. };
  5283. }
  5284. sched_domain_topology = tl;
  5285. sched_domains_numa_levels = level;
  5286. }
  5287. static void sched_domains_numa_masks_set(int cpu)
  5288. {
  5289. int i, j;
  5290. int node = cpu_to_node(cpu);
  5291. for (i = 0; i < sched_domains_numa_levels; i++) {
  5292. for (j = 0; j < nr_node_ids; j++) {
  5293. if (node_distance(j, node) <= sched_domains_numa_distance[i])
  5294. cpumask_set_cpu(cpu, sched_domains_numa_masks[i][j]);
  5295. }
  5296. }
  5297. }
  5298. static void sched_domains_numa_masks_clear(int cpu)
  5299. {
  5300. int i, j;
  5301. for (i = 0; i < sched_domains_numa_levels; i++) {
  5302. for (j = 0; j < nr_node_ids; j++)
  5303. cpumask_clear_cpu(cpu, sched_domains_numa_masks[i][j]);
  5304. }
  5305. }
  5306. /*
  5307. * Update sched_domains_numa_masks[level][node] array when new cpus
  5308. * are onlined.
  5309. */
  5310. static int sched_domains_numa_masks_update(struct notifier_block *nfb,
  5311. unsigned long action,
  5312. void *hcpu)
  5313. {
  5314. int cpu = (long)hcpu;
  5315. switch (action & ~CPU_TASKS_FROZEN) {
  5316. case CPU_ONLINE:
  5317. sched_domains_numa_masks_set(cpu);
  5318. break;
  5319. case CPU_DEAD:
  5320. sched_domains_numa_masks_clear(cpu);
  5321. break;
  5322. default:
  5323. return NOTIFY_DONE;
  5324. }
  5325. return NOTIFY_OK;
  5326. }
  5327. #else
  5328. static inline void sched_init_numa(void)
  5329. {
  5330. }
  5331. static int sched_domains_numa_masks_update(struct notifier_block *nfb,
  5332. unsigned long action,
  5333. void *hcpu)
  5334. {
  5335. return 0;
  5336. }
  5337. #endif /* CONFIG_NUMA */
  5338. static int __sdt_alloc(const struct cpumask *cpu_map)
  5339. {
  5340. struct sched_domain_topology_level *tl;
  5341. int j;
  5342. for (tl = sched_domain_topology; tl->init; tl++) {
  5343. struct sd_data *sdd = &tl->data;
  5344. sdd->sd = alloc_percpu(struct sched_domain *);
  5345. if (!sdd->sd)
  5346. return -ENOMEM;
  5347. sdd->sg = alloc_percpu(struct sched_group *);
  5348. if (!sdd->sg)
  5349. return -ENOMEM;
  5350. sdd->sgp = alloc_percpu(struct sched_group_power *);
  5351. if (!sdd->sgp)
  5352. return -ENOMEM;
  5353. for_each_cpu(j, cpu_map) {
  5354. struct sched_domain *sd;
  5355. struct sched_group *sg;
  5356. struct sched_group_power *sgp;
  5357. sd = kzalloc_node(sizeof(struct sched_domain) + cpumask_size(),
  5358. GFP_KERNEL, cpu_to_node(j));
  5359. if (!sd)
  5360. return -ENOMEM;
  5361. *per_cpu_ptr(sdd->sd, j) = sd;
  5362. sg = kzalloc_node(sizeof(struct sched_group) + cpumask_size(),
  5363. GFP_KERNEL, cpu_to_node(j));
  5364. if (!sg)
  5365. return -ENOMEM;
  5366. sg->next = sg;
  5367. *per_cpu_ptr(sdd->sg, j) = sg;
  5368. sgp = kzalloc_node(sizeof(struct sched_group_power) + cpumask_size(),
  5369. GFP_KERNEL, cpu_to_node(j));
  5370. if (!sgp)
  5371. return -ENOMEM;
  5372. *per_cpu_ptr(sdd->sgp, j) = sgp;
  5373. }
  5374. }
  5375. return 0;
  5376. }
  5377. static void __sdt_free(const struct cpumask *cpu_map)
  5378. {
  5379. struct sched_domain_topology_level *tl;
  5380. int j;
  5381. for (tl = sched_domain_topology; tl->init; tl++) {
  5382. struct sd_data *sdd = &tl->data;
  5383. for_each_cpu(j, cpu_map) {
  5384. struct sched_domain *sd;
  5385. if (sdd->sd) {
  5386. sd = *per_cpu_ptr(sdd->sd, j);
  5387. if (sd && (sd->flags & SD_OVERLAP))
  5388. free_sched_groups(sd->groups, 0);
  5389. kfree(*per_cpu_ptr(sdd->sd, j));
  5390. }
  5391. if (sdd->sg)
  5392. kfree(*per_cpu_ptr(sdd->sg, j));
  5393. if (sdd->sgp)
  5394. kfree(*per_cpu_ptr(sdd->sgp, j));
  5395. }
  5396. free_percpu(sdd->sd);
  5397. sdd->sd = NULL;
  5398. free_percpu(sdd->sg);
  5399. sdd->sg = NULL;
  5400. free_percpu(sdd->sgp);
  5401. sdd->sgp = NULL;
  5402. }
  5403. }
  5404. struct sched_domain *build_sched_domain(struct sched_domain_topology_level *tl,
  5405. struct s_data *d, const struct cpumask *cpu_map,
  5406. struct sched_domain_attr *attr, struct sched_domain *child,
  5407. int cpu)
  5408. {
  5409. struct sched_domain *sd = tl->init(tl, cpu);
  5410. if (!sd)
  5411. return child;
  5412. cpumask_and(sched_domain_span(sd), cpu_map, tl->mask(cpu));
  5413. if (child) {
  5414. sd->level = child->level + 1;
  5415. sched_domain_level_max = max(sched_domain_level_max, sd->level);
  5416. child->parent = sd;
  5417. }
  5418. sd->child = child;
  5419. set_domain_attribute(sd, attr);
  5420. return sd;
  5421. }
  5422. /*
  5423. * Build sched domains for a given set of cpus and attach the sched domains
  5424. * to the individual cpus
  5425. */
  5426. static int build_sched_domains(const struct cpumask *cpu_map,
  5427. struct sched_domain_attr *attr)
  5428. {
  5429. enum s_alloc alloc_state = sa_none;
  5430. struct sched_domain *sd;
  5431. struct s_data d;
  5432. int i, ret = -ENOMEM;
  5433. alloc_state = __visit_domain_allocation_hell(&d, cpu_map);
  5434. if (alloc_state != sa_rootdomain)
  5435. goto error;
  5436. /* Set up domains for cpus specified by the cpu_map. */
  5437. for_each_cpu(i, cpu_map) {
  5438. struct sched_domain_topology_level *tl;
  5439. sd = NULL;
  5440. for (tl = sched_domain_topology; tl->init; tl++) {
  5441. sd = build_sched_domain(tl, &d, cpu_map, attr, sd, i);
  5442. if (tl->flags & SDTL_OVERLAP || sched_feat(FORCE_SD_OVERLAP))
  5443. sd->flags |= SD_OVERLAP;
  5444. if (cpumask_equal(cpu_map, sched_domain_span(sd)))
  5445. break;
  5446. }
  5447. while (sd->child)
  5448. sd = sd->child;
  5449. *per_cpu_ptr(d.sd, i) = sd;
  5450. }
  5451. /* Build the groups for the domains */
  5452. for_each_cpu(i, cpu_map) {
  5453. for (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent) {
  5454. sd->span_weight = cpumask_weight(sched_domain_span(sd));
  5455. if (sd->flags & SD_OVERLAP) {
  5456. if (build_overlap_sched_groups(sd, i))
  5457. goto error;
  5458. } else {
  5459. if (build_sched_groups(sd, i))
  5460. goto error;
  5461. }
  5462. }
  5463. }
  5464. /* Calculate CPU power for physical packages and nodes */
  5465. for (i = nr_cpumask_bits-1; i >= 0; i--) {
  5466. if (!cpumask_test_cpu(i, cpu_map))
  5467. continue;
  5468. for (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent) {
  5469. claim_allocations(i, sd);
  5470. init_sched_groups_power(i, sd);
  5471. }
  5472. }
  5473. /* Attach the domains */
  5474. rcu_read_lock();
  5475. for_each_cpu(i, cpu_map) {
  5476. sd = *per_cpu_ptr(d.sd, i);
  5477. cpu_attach_domain(sd, d.rd, i);
  5478. }
  5479. rcu_read_unlock();
  5480. ret = 0;
  5481. error:
  5482. __free_domain_allocs(&d, alloc_state, cpu_map);
  5483. return ret;
  5484. }
  5485. static cpumask_var_t *doms_cur; /* current sched domains */
  5486. static int ndoms_cur; /* number of sched domains in 'doms_cur' */
  5487. static struct sched_domain_attr *dattr_cur;
  5488. /* attribues of custom domains in 'doms_cur' */
  5489. /*
  5490. * Special case: If a kmalloc of a doms_cur partition (array of
  5491. * cpumask) fails, then fallback to a single sched domain,
  5492. * as determined by the single cpumask fallback_doms.
  5493. */
  5494. static cpumask_var_t fallback_doms;
  5495. /*
  5496. * arch_update_cpu_topology lets virtualized architectures update the
  5497. * cpu core maps. It is supposed to return 1 if the topology changed
  5498. * or 0 if it stayed the same.
  5499. */
  5500. int __attribute__((weak)) arch_update_cpu_topology(void)
  5501. {
  5502. return 0;
  5503. }
  5504. cpumask_var_t *alloc_sched_domains(unsigned int ndoms)
  5505. {
  5506. int i;
  5507. cpumask_var_t *doms;
  5508. doms = kmalloc(sizeof(*doms) * ndoms, GFP_KERNEL);
  5509. if (!doms)
  5510. return NULL;
  5511. for (i = 0; i < ndoms; i++) {
  5512. if (!alloc_cpumask_var(&doms[i], GFP_KERNEL)) {
  5513. free_sched_domains(doms, i);
  5514. return NULL;
  5515. }
  5516. }
  5517. return doms;
  5518. }
  5519. void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms)
  5520. {
  5521. unsigned int i;
  5522. for (i = 0; i < ndoms; i++)
  5523. free_cpumask_var(doms[i]);
  5524. kfree(doms);
  5525. }
  5526. /*
  5527. * Set up scheduler domains and groups. Callers must hold the hotplug lock.
  5528. * For now this just excludes isolated cpus, but could be used to
  5529. * exclude other special cases in the future.
  5530. */
  5531. static int init_sched_domains(const struct cpumask *cpu_map)
  5532. {
  5533. int err;
  5534. arch_update_cpu_topology();
  5535. ndoms_cur = 1;
  5536. doms_cur = alloc_sched_domains(ndoms_cur);
  5537. if (!doms_cur)
  5538. doms_cur = &fallback_doms;
  5539. cpumask_andnot(doms_cur[0], cpu_map, cpu_isolated_map);
  5540. err = build_sched_domains(doms_cur[0], NULL);
  5541. register_sched_domain_sysctl();
  5542. return err;
  5543. }
  5544. /*
  5545. * Detach sched domains from a group of cpus specified in cpu_map
  5546. * These cpus will now be attached to the NULL domain
  5547. */
  5548. static void detach_destroy_domains(const struct cpumask *cpu_map)
  5549. {
  5550. int i;
  5551. rcu_read_lock();
  5552. for_each_cpu(i, cpu_map)
  5553. cpu_attach_domain(NULL, &def_root_domain, i);
  5554. rcu_read_unlock();
  5555. }
  5556. /* handle null as "default" */
  5557. static int dattrs_equal(struct sched_domain_attr *cur, int idx_cur,
  5558. struct sched_domain_attr *new, int idx_new)
  5559. {
  5560. struct sched_domain_attr tmp;
  5561. /* fast path */
  5562. if (!new && !cur)
  5563. return 1;
  5564. tmp = SD_ATTR_INIT;
  5565. return !memcmp(cur ? (cur + idx_cur) : &tmp,
  5566. new ? (new + idx_new) : &tmp,
  5567. sizeof(struct sched_domain_attr));
  5568. }
  5569. /*
  5570. * Partition sched domains as specified by the 'ndoms_new'
  5571. * cpumasks in the array doms_new[] of cpumasks. This compares
  5572. * doms_new[] to the current sched domain partitioning, doms_cur[].
  5573. * It destroys each deleted domain and builds each new domain.
  5574. *
  5575. * 'doms_new' is an array of cpumask_var_t's of length 'ndoms_new'.
  5576. * The masks don't intersect (don't overlap.) We should setup one
  5577. * sched domain for each mask. CPUs not in any of the cpumasks will
  5578. * not be load balanced. If the same cpumask appears both in the
  5579. * current 'doms_cur' domains and in the new 'doms_new', we can leave
  5580. * it as it is.
  5581. *
  5582. * The passed in 'doms_new' should be allocated using
  5583. * alloc_sched_domains. This routine takes ownership of it and will
  5584. * free_sched_domains it when done with it. If the caller failed the
  5585. * alloc call, then it can pass in doms_new == NULL && ndoms_new == 1,
  5586. * and partition_sched_domains() will fallback to the single partition
  5587. * 'fallback_doms', it also forces the domains to be rebuilt.
  5588. *
  5589. * If doms_new == NULL it will be replaced with cpu_online_mask.
  5590. * ndoms_new == 0 is a special case for destroying existing domains,
  5591. * and it will not create the default domain.
  5592. *
  5593. * Call with hotplug lock held
  5594. */
  5595. void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
  5596. struct sched_domain_attr *dattr_new)
  5597. {
  5598. int i, j, n;
  5599. int new_topology;
  5600. mutex_lock(&sched_domains_mutex);
  5601. /* always unregister in case we don't destroy any domains */
  5602. unregister_sched_domain_sysctl();
  5603. /* Let architecture update cpu core mappings. */
  5604. new_topology = arch_update_cpu_topology();
  5605. n = doms_new ? ndoms_new : 0;
  5606. /* Destroy deleted domains */
  5607. for (i = 0; i < ndoms_cur; i++) {
  5608. for (j = 0; j < n && !new_topology; j++) {
  5609. if (cpumask_equal(doms_cur[i], doms_new[j])
  5610. && dattrs_equal(dattr_cur, i, dattr_new, j))
  5611. goto match1;
  5612. }
  5613. /* no match - a current sched domain not in new doms_new[] */
  5614. detach_destroy_domains(doms_cur[i]);
  5615. match1:
  5616. ;
  5617. }
  5618. if (doms_new == NULL) {
  5619. ndoms_cur = 0;
  5620. doms_new = &fallback_doms;
  5621. cpumask_andnot(doms_new[0], cpu_active_mask, cpu_isolated_map);
  5622. WARN_ON_ONCE(dattr_new);
  5623. }
  5624. /* Build new domains */
  5625. for (i = 0; i < ndoms_new; i++) {
  5626. for (j = 0; j < ndoms_cur && !new_topology; j++) {
  5627. if (cpumask_equal(doms_new[i], doms_cur[j])
  5628. && dattrs_equal(dattr_new, i, dattr_cur, j))
  5629. goto match2;
  5630. }
  5631. /* no match - add a new doms_new */
  5632. build_sched_domains(doms_new[i], dattr_new ? dattr_new + i : NULL);
  5633. match2:
  5634. ;
  5635. }
  5636. /* Remember the new sched domains */
  5637. if (doms_cur != &fallback_doms)
  5638. free_sched_domains(doms_cur, ndoms_cur);
  5639. kfree(dattr_cur); /* kfree(NULL) is safe */
  5640. doms_cur = doms_new;
  5641. dattr_cur = dattr_new;
  5642. ndoms_cur = ndoms_new;
  5643. register_sched_domain_sysctl();
  5644. mutex_unlock(&sched_domains_mutex);
  5645. }
  5646. static int num_cpus_frozen; /* used to mark begin/end of suspend/resume */
  5647. /*
  5648. * Update cpusets according to cpu_active mask. If cpusets are
  5649. * disabled, cpuset_update_active_cpus() becomes a simple wrapper
  5650. * around partition_sched_domains().
  5651. *
  5652. * If we come here as part of a suspend/resume, don't touch cpusets because we
  5653. * want to restore it back to its original state upon resume anyway.
  5654. */
  5655. static int cpuset_cpu_active(struct notifier_block *nfb, unsigned long action,
  5656. void *hcpu)
  5657. {
  5658. switch (action) {
  5659. case CPU_ONLINE_FROZEN:
  5660. case CPU_DOWN_FAILED_FROZEN:
  5661. /*
  5662. * num_cpus_frozen tracks how many CPUs are involved in suspend
  5663. * resume sequence. As long as this is not the last online
  5664. * operation in the resume sequence, just build a single sched
  5665. * domain, ignoring cpusets.
  5666. */
  5667. num_cpus_frozen--;
  5668. if (likely(num_cpus_frozen)) {
  5669. partition_sched_domains(1, NULL, NULL);
  5670. break;
  5671. }
  5672. /*
  5673. * This is the last CPU online operation. So fall through and
  5674. * restore the original sched domains by considering the
  5675. * cpuset configurations.
  5676. */
  5677. case CPU_ONLINE:
  5678. case CPU_DOWN_FAILED:
  5679. cpuset_update_active_cpus(true);
  5680. break;
  5681. default:
  5682. return NOTIFY_DONE;
  5683. }
  5684. return NOTIFY_OK;
  5685. }
  5686. static int cpuset_cpu_inactive(struct notifier_block *nfb, unsigned long action,
  5687. void *hcpu)
  5688. {
  5689. switch (action) {
  5690. case CPU_DOWN_PREPARE:
  5691. cpuset_update_active_cpus(false);
  5692. break;
  5693. case CPU_DOWN_PREPARE_FROZEN:
  5694. num_cpus_frozen++;
  5695. partition_sched_domains(1, NULL, NULL);
  5696. break;
  5697. default:
  5698. return NOTIFY_DONE;
  5699. }
  5700. return NOTIFY_OK;
  5701. }
  5702. void __init sched_init_smp(void)
  5703. {
  5704. cpumask_var_t non_isolated_cpus;
  5705. alloc_cpumask_var(&non_isolated_cpus, GFP_KERNEL);
  5706. alloc_cpumask_var(&fallback_doms, GFP_KERNEL);
  5707. sched_init_numa();
  5708. get_online_cpus();
  5709. mutex_lock(&sched_domains_mutex);
  5710. init_sched_domains(cpu_active_mask);
  5711. cpumask_andnot(non_isolated_cpus, cpu_possible_mask, cpu_isolated_map);
  5712. if (cpumask_empty(non_isolated_cpus))
  5713. cpumask_set_cpu(smp_processor_id(), non_isolated_cpus);
  5714. mutex_unlock(&sched_domains_mutex);
  5715. put_online_cpus();
  5716. hotcpu_notifier(sched_domains_numa_masks_update, CPU_PRI_SCHED_ACTIVE);
  5717. hotcpu_notifier(cpuset_cpu_active, CPU_PRI_CPUSET_ACTIVE);
  5718. hotcpu_notifier(cpuset_cpu_inactive, CPU_PRI_CPUSET_INACTIVE);
  5719. /* RT runtime code needs to handle some hotplug events */
  5720. hotcpu_notifier(update_runtime, 0);
  5721. init_hrtick();
  5722. /* Move init over to a non-isolated CPU */
  5723. if (set_cpus_allowed_ptr(current, non_isolated_cpus) < 0)
  5724. BUG();
  5725. sched_init_granularity();
  5726. free_cpumask_var(non_isolated_cpus);
  5727. init_sched_rt_class();
  5728. }
  5729. #else
  5730. void __init sched_init_smp(void)
  5731. {
  5732. sched_init_granularity();
  5733. }
  5734. #endif /* CONFIG_SMP */
  5735. const_debug unsigned int sysctl_timer_migration = 1;
  5736. int in_sched_functions(unsigned long addr)
  5737. {
  5738. return in_lock_functions(addr) ||
  5739. (addr >= (unsigned long)__sched_text_start
  5740. && addr < (unsigned long)__sched_text_end);
  5741. }
  5742. #ifdef CONFIG_CGROUP_SCHED
  5743. struct task_group root_task_group;
  5744. LIST_HEAD(task_groups);
  5745. #endif
  5746. DECLARE_PER_CPU(cpumask_var_t, load_balance_tmpmask);
  5747. void __init sched_init(void)
  5748. {
  5749. int i, j;
  5750. unsigned long alloc_size = 0, ptr;
  5751. #ifdef CONFIG_FAIR_GROUP_SCHED
  5752. alloc_size += 2 * nr_cpu_ids * sizeof(void **);
  5753. #endif
  5754. #ifdef CONFIG_RT_GROUP_SCHED
  5755. alloc_size += 2 * nr_cpu_ids * sizeof(void **);
  5756. #endif
  5757. #ifdef CONFIG_CPUMASK_OFFSTACK
  5758. alloc_size += num_possible_cpus() * cpumask_size();
  5759. #endif
  5760. if (alloc_size) {
  5761. ptr = (unsigned long)kzalloc(alloc_size, GFP_NOWAIT);
  5762. #ifdef CONFIG_FAIR_GROUP_SCHED
  5763. root_task_group.se = (struct sched_entity **)ptr;
  5764. ptr += nr_cpu_ids * sizeof(void **);
  5765. root_task_group.cfs_rq = (struct cfs_rq **)ptr;
  5766. ptr += nr_cpu_ids * sizeof(void **);
  5767. #endif /* CONFIG_FAIR_GROUP_SCHED */
  5768. #ifdef CONFIG_RT_GROUP_SCHED
  5769. root_task_group.rt_se = (struct sched_rt_entity **)ptr;
  5770. ptr += nr_cpu_ids * sizeof(void **);
  5771. root_task_group.rt_rq = (struct rt_rq **)ptr;
  5772. ptr += nr_cpu_ids * sizeof(void **);
  5773. #endif /* CONFIG_RT_GROUP_SCHED */
  5774. #ifdef CONFIG_CPUMASK_OFFSTACK
  5775. for_each_possible_cpu(i) {
  5776. per_cpu(load_balance_tmpmask, i) = (void *)ptr;
  5777. ptr += cpumask_size();
  5778. }
  5779. #endif /* CONFIG_CPUMASK_OFFSTACK */
  5780. }
  5781. #ifdef CONFIG_SMP
  5782. init_defrootdomain();
  5783. #endif
  5784. init_rt_bandwidth(&def_rt_bandwidth,
  5785. global_rt_period(), global_rt_runtime());
  5786. #ifdef CONFIG_RT_GROUP_SCHED
  5787. init_rt_bandwidth(&root_task_group.rt_bandwidth,
  5788. global_rt_period(), global_rt_runtime());
  5789. #endif /* CONFIG_RT_GROUP_SCHED */
  5790. #ifdef CONFIG_CGROUP_SCHED
  5791. list_add(&root_task_group.list, &task_groups);
  5792. INIT_LIST_HEAD(&root_task_group.children);
  5793. INIT_LIST_HEAD(&root_task_group.siblings);
  5794. autogroup_init(&init_task);
  5795. #endif /* CONFIG_CGROUP_SCHED */
  5796. #ifdef CONFIG_CGROUP_CPUACCT
  5797. root_cpuacct.cpustat = &kernel_cpustat;
  5798. root_cpuacct.cpuusage = alloc_percpu(u64);
  5799. /* Too early, not expected to fail */
  5800. BUG_ON(!root_cpuacct.cpuusage);
  5801. #endif
  5802. for_each_possible_cpu(i) {
  5803. struct rq *rq;
  5804. rq = cpu_rq(i);
  5805. raw_spin_lock_init(&rq->lock);
  5806. rq->nr_running = 0;
  5807. rq->calc_load_active = 0;
  5808. rq->calc_load_update = jiffies + LOAD_FREQ;
  5809. init_cfs_rq(&rq->cfs);
  5810. init_rt_rq(&rq->rt, rq);
  5811. #ifdef CONFIG_FAIR_GROUP_SCHED
  5812. root_task_group.shares = ROOT_TASK_GROUP_LOAD;
  5813. INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);
  5814. /*
  5815. * How much cpu bandwidth does root_task_group get?
  5816. *
  5817. * In case of task-groups formed thr' the cgroup filesystem, it
  5818. * gets 100% of the cpu resources in the system. This overall
  5819. * system cpu resource is divided among the tasks of
  5820. * root_task_group and its child task-groups in a fair manner,
  5821. * based on each entity's (task or task-group's) weight
  5822. * (se->load.weight).
  5823. *
  5824. * In other words, if root_task_group has 10 tasks of weight
  5825. * 1024) and two child groups A0 and A1 (of weight 1024 each),
  5826. * then A0's share of the cpu resource is:
  5827. *
  5828. * A0's bandwidth = 1024 / (10*1024 + 1024 + 1024) = 8.33%
  5829. *
  5830. * We achieve this by letting root_task_group's tasks sit
  5831. * directly in rq->cfs (i.e root_task_group->se[] = NULL).
  5832. */
  5833. init_cfs_bandwidth(&root_task_group.cfs_bandwidth);
  5834. init_tg_cfs_entry(&root_task_group, &rq->cfs, NULL, i, NULL);
  5835. #endif /* CONFIG_FAIR_GROUP_SCHED */
  5836. rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
  5837. #ifdef CONFIG_RT_GROUP_SCHED
  5838. INIT_LIST_HEAD(&rq->leaf_rt_rq_list);
  5839. init_tg_rt_entry(&root_task_group, &rq->rt, NULL, i, NULL);
  5840. #endif
  5841. for (j = 0; j < CPU_LOAD_IDX_MAX; j++)
  5842. rq->cpu_load[j] = 0;
  5843. rq->last_load_update_tick = jiffies;
  5844. #ifdef CONFIG_SMP
  5845. rq->sd = NULL;
  5846. rq->rd = NULL;
  5847. rq->cpu_power = SCHED_POWER_SCALE;
  5848. rq->post_schedule = 0;
  5849. rq->active_balance = 0;
  5850. rq->next_balance = jiffies;
  5851. rq->push_cpu = 0;
  5852. rq->cpu = i;
  5853. rq->online = 0;
  5854. rq->idle_stamp = 0;
  5855. rq->avg_idle = 2*sysctl_sched_migration_cost;
  5856. INIT_LIST_HEAD(&rq->cfs_tasks);
  5857. rq_attach_root(rq, &def_root_domain);
  5858. #ifdef CONFIG_NO_HZ
  5859. rq->nohz_flags = 0;
  5860. #endif
  5861. #endif
  5862. init_rq_hrtick(rq);
  5863. atomic_set(&rq->nr_iowait, 0);
  5864. }
  5865. set_load_weight(&init_task);
  5866. #ifdef CONFIG_PREEMPT_NOTIFIERS
  5867. INIT_HLIST_HEAD(&init_task.preempt_notifiers);
  5868. #endif
  5869. #ifdef CONFIG_RT_MUTEXES
  5870. plist_head_init(&init_task.pi_waiters);
  5871. #endif
  5872. /*
  5873. * The boot idle thread does lazy MMU switching as well:
  5874. */
  5875. atomic_inc(&init_mm.mm_count);
  5876. enter_lazy_tlb(&init_mm, current);
  5877. /*
  5878. * Make us the idle thread. Technically, schedule() should not be
  5879. * called from this thread, however somewhere below it might be,
  5880. * but because we are the idle thread, we just pick up running again
  5881. * when this runqueue becomes "idle".
  5882. */
  5883. init_idle(current, smp_processor_id());
  5884. calc_load_update = jiffies + LOAD_FREQ;
  5885. /*
  5886. * During early bootup we pretend to be a normal task:
  5887. */
  5888. current->sched_class = &fair_sched_class;
  5889. #ifdef CONFIG_SMP
  5890. zalloc_cpumask_var(&sched_domains_tmpmask, GFP_NOWAIT);
  5891. /* May be allocated at isolcpus cmdline parse time */
  5892. if (cpu_isolated_map == NULL)
  5893. zalloc_cpumask_var(&cpu_isolated_map, GFP_NOWAIT);
  5894. idle_thread_set_boot_cpu();
  5895. #endif
  5896. init_sched_fair_class();
  5897. scheduler_running = 1;
  5898. }
  5899. #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
  5900. static inline int preempt_count_equals(int preempt_offset)
  5901. {
  5902. int nested = (preempt_count() & ~PREEMPT_ACTIVE) + rcu_preempt_depth();
  5903. return (nested == preempt_offset);
  5904. }
  5905. void __might_sleep(const char *file, int line, int preempt_offset)
  5906. {
  5907. static unsigned long prev_jiffy; /* ratelimiting */
  5908. rcu_sleep_check(); /* WARN_ON_ONCE() by default, no rate limit reqd. */
  5909. if ((preempt_count_equals(preempt_offset) && !irqs_disabled()) ||
  5910. system_state != SYSTEM_RUNNING || oops_in_progress)
  5911. return;
  5912. if (time_before(jiffies, prev_jiffy + HZ) && prev_jiffy)
  5913. return;
  5914. prev_jiffy = jiffies;
  5915. printk(KERN_ERR
  5916. "BUG: sleeping function called from invalid context at %s:%d\n",
  5917. file, line);
  5918. printk(KERN_ERR
  5919. "in_atomic(): %d, irqs_disabled(): %d, pid: %d, name: %s\n",
  5920. in_atomic(), irqs_disabled(),
  5921. current->pid, current->comm);
  5922. debug_show_held_locks(current);
  5923. if (irqs_disabled())
  5924. print_irqtrace_events(current);
  5925. dump_stack();
  5926. }
  5927. EXPORT_SYMBOL(__might_sleep);
  5928. #endif
  5929. #ifdef CONFIG_MAGIC_SYSRQ
  5930. static void normalize_task(struct rq *rq, struct task_struct *p)
  5931. {
  5932. const struct sched_class *prev_class = p->sched_class;
  5933. int old_prio = p->prio;
  5934. int on_rq;
  5935. on_rq = p->on_rq;
  5936. if (on_rq)
  5937. dequeue_task(rq, p, 0);
  5938. __setscheduler(rq, p, SCHED_NORMAL, 0);
  5939. if (on_rq) {
  5940. enqueue_task(rq, p, 0);
  5941. resched_task(rq->curr);
  5942. }
  5943. check_class_changed(rq, p, prev_class, old_prio);
  5944. }
  5945. void normalize_rt_tasks(void)
  5946. {
  5947. struct task_struct *g, *p;
  5948. unsigned long flags;
  5949. struct rq *rq;
  5950. read_lock_irqsave(&tasklist_lock, flags);
  5951. do_each_thread(g, p) {
  5952. /*
  5953. * Only normalize user tasks:
  5954. */
  5955. if (!p->mm)
  5956. continue;
  5957. p->se.exec_start = 0;
  5958. #ifdef CONFIG_SCHEDSTATS
  5959. p->se.statistics.wait_start = 0;
  5960. p->se.statistics.sleep_start = 0;
  5961. p->se.statistics.block_start = 0;
  5962. #endif
  5963. if (!rt_task(p)) {
  5964. /*
  5965. * Renice negative nice level userspace
  5966. * tasks back to 0:
  5967. */
  5968. if (TASK_NICE(p) < 0 && p->mm)
  5969. set_user_nice(p, 0);
  5970. continue;
  5971. }
  5972. raw_spin_lock(&p->pi_lock);
  5973. rq = __task_rq_lock(p);
  5974. normalize_task(rq, p);
  5975. __task_rq_unlock(rq);
  5976. raw_spin_unlock(&p->pi_lock);
  5977. } while_each_thread(g, p);
  5978. read_unlock_irqrestore(&tasklist_lock, flags);
  5979. }
  5980. #endif /* CONFIG_MAGIC_SYSRQ */
  5981. #if defined(CONFIG_IA64) || defined(CONFIG_KGDB_KDB)
  5982. /*
  5983. * These functions are only useful for the IA64 MCA handling, or kdb.
  5984. *
  5985. * They can only be called when the whole system has been
  5986. * stopped - every CPU needs to be quiescent, and no scheduling
  5987. * activity can take place. Using them for anything else would
  5988. * be a serious bug, and as a result, they aren't even visible
  5989. * under any other configuration.
  5990. */
  5991. /**
  5992. * curr_task - return the current task for a given cpu.
  5993. * @cpu: the processor in question.
  5994. *
  5995. * ONLY VALID WHEN THE WHOLE SYSTEM IS STOPPED!
  5996. */
  5997. struct task_struct *curr_task(int cpu)
  5998. {
  5999. return cpu_curr(cpu);
  6000. }
  6001. #endif /* defined(CONFIG_IA64) || defined(CONFIG_KGDB_KDB) */
  6002. #ifdef CONFIG_IA64
  6003. /**
  6004. * set_curr_task - set the current task for a given cpu.
  6005. * @cpu: the processor in question.
  6006. * @p: the task pointer to set.
  6007. *
  6008. * Description: This function must only be used when non-maskable interrupts
  6009. * are serviced on a separate stack. It allows the architecture to switch the
  6010. * notion of the current task on a cpu in a non-blocking manner. This function
  6011. * must be called with all CPU's synchronized, and interrupts disabled, the
  6012. * and caller must save the original value of the current task (see
  6013. * curr_task() above) and restore that value before reenabling interrupts and
  6014. * re-starting the system.
  6015. *
  6016. * ONLY VALID WHEN THE WHOLE SYSTEM IS STOPPED!
  6017. */
  6018. void set_curr_task(int cpu, struct task_struct *p)
  6019. {
  6020. cpu_curr(cpu) = p;
  6021. }
  6022. #endif
  6023. #ifdef CONFIG_CGROUP_SCHED
  6024. /* task_group_lock serializes the addition/removal of task groups */
  6025. static DEFINE_SPINLOCK(task_group_lock);
  6026. static void free_sched_group(struct task_group *tg)
  6027. {
  6028. free_fair_sched_group(tg);
  6029. free_rt_sched_group(tg);
  6030. autogroup_free(tg);
  6031. kfree(tg);
  6032. }
  6033. /* allocate runqueue etc for a new task group */
  6034. struct task_group *sched_create_group(struct task_group *parent)
  6035. {
  6036. struct task_group *tg;
  6037. unsigned long flags;
  6038. tg = kzalloc(sizeof(*tg), GFP_KERNEL);
  6039. if (!tg)
  6040. return ERR_PTR(-ENOMEM);
  6041. if (!alloc_fair_sched_group(tg, parent))
  6042. goto err;
  6043. if (!alloc_rt_sched_group(tg, parent))
  6044. goto err;
  6045. spin_lock_irqsave(&task_group_lock, flags);
  6046. list_add_rcu(&tg->list, &task_groups);
  6047. WARN_ON(!parent); /* root should already exist */
  6048. tg->parent = parent;
  6049. INIT_LIST_HEAD(&tg->children);
  6050. list_add_rcu(&tg->siblings, &parent->children);
  6051. spin_unlock_irqrestore(&task_group_lock, flags);
  6052. return tg;
  6053. err:
  6054. free_sched_group(tg);
  6055. return ERR_PTR(-ENOMEM);
  6056. }
  6057. /* rcu callback to free various structures associated with a task group */
  6058. static void free_sched_group_rcu(struct rcu_head *rhp)
  6059. {
  6060. /* now it should be safe to free those cfs_rqs */
  6061. free_sched_group(container_of(rhp, struct task_group, rcu));
  6062. }
  6063. /* Destroy runqueue etc associated with a task group */
  6064. void sched_destroy_group(struct task_group *tg)
  6065. {
  6066. unsigned long flags;
  6067. int i;
  6068. /* end participation in shares distribution */
  6069. for_each_possible_cpu(i)
  6070. unregister_fair_sched_group(tg, i);
  6071. spin_lock_irqsave(&task_group_lock, flags);
  6072. list_del_rcu(&tg->list);
  6073. list_del_rcu(&tg->siblings);
  6074. spin_unlock_irqrestore(&task_group_lock, flags);
  6075. /* wait for possible concurrent references to cfs_rqs complete */
  6076. call_rcu(&tg->rcu, free_sched_group_rcu);
  6077. }
  6078. /* change task's runqueue when it moves between groups.
  6079. * The caller of this function should have put the task in its new group
  6080. * by now. This function just updates tsk->se.cfs_rq and tsk->se.parent to
  6081. * reflect its new group.
  6082. */
  6083. void sched_move_task(struct task_struct *tsk)
  6084. {
  6085. struct task_group *tg;
  6086. int on_rq, running;
  6087. unsigned long flags;
  6088. struct rq *rq;
  6089. rq = task_rq_lock(tsk, &flags);
  6090. running = task_current(rq, tsk);
  6091. on_rq = tsk->on_rq;
  6092. if (on_rq)
  6093. dequeue_task(rq, tsk, 0);
  6094. if (unlikely(running))
  6095. tsk->sched_class->put_prev_task(rq, tsk);
  6096. tg = container_of(task_subsys_state_check(tsk, cpu_cgroup_subsys_id,
  6097. lockdep_is_held(&tsk->sighand->siglock)),
  6098. struct task_group, css);
  6099. tg = autogroup_task_group(tsk, tg);
  6100. tsk->sched_task_group = tg;
  6101. #ifdef CONFIG_FAIR_GROUP_SCHED
  6102. if (tsk->sched_class->task_move_group)
  6103. tsk->sched_class->task_move_group(tsk, on_rq);
  6104. else
  6105. #endif
  6106. set_task_rq(tsk, task_cpu(tsk));
  6107. if (unlikely(running))
  6108. tsk->sched_class->set_curr_task(rq);
  6109. if (on_rq)
  6110. enqueue_task(rq, tsk, 0);
  6111. task_rq_unlock(rq, tsk, &flags);
  6112. }
  6113. #endif /* CONFIG_CGROUP_SCHED */
  6114. #if defined(CONFIG_RT_GROUP_SCHED) || defined(CONFIG_CFS_BANDWIDTH)
  6115. static unsigned long to_ratio(u64 period, u64 runtime)
  6116. {
  6117. if (runtime == RUNTIME_INF)
  6118. return 1ULL << 20;
  6119. return div64_u64(runtime << 20, period);
  6120. }
  6121. #endif
  6122. #ifdef CONFIG_RT_GROUP_SCHED
  6123. /*
  6124. * Ensure that the real time constraints are schedulable.
  6125. */
  6126. static DEFINE_MUTEX(rt_constraints_mutex);
  6127. /* Must be called with tasklist_lock held */
  6128. static inline int tg_has_rt_tasks(struct task_group *tg)
  6129. {
  6130. struct task_struct *g, *p;
  6131. do_each_thread(g, p) {
  6132. if (rt_task(p) && task_rq(p)->rt.tg == tg)
  6133. return 1;
  6134. } while_each_thread(g, p);
  6135. return 0;
  6136. }
  6137. struct rt_schedulable_data {
  6138. struct task_group *tg;
  6139. u64 rt_period;
  6140. u64 rt_runtime;
  6141. };
  6142. static int tg_rt_schedulable(struct task_group *tg, void *data)
  6143. {
  6144. struct rt_schedulable_data *d = data;
  6145. struct task_group *child;
  6146. unsigned long total, sum = 0;
  6147. u64 period, runtime;
  6148. period = ktime_to_ns(tg->rt_bandwidth.rt_period);
  6149. runtime = tg->rt_bandwidth.rt_runtime;
  6150. if (tg == d->tg) {
  6151. period = d->rt_period;
  6152. runtime = d->rt_runtime;
  6153. }
  6154. /*
  6155. * Cannot have more runtime than the period.
  6156. */
  6157. if (runtime > period && runtime != RUNTIME_INF)
  6158. return -EINVAL;
  6159. /*
  6160. * Ensure we don't starve existing RT tasks.
  6161. */
  6162. if (rt_bandwidth_enabled() && !runtime && tg_has_rt_tasks(tg))
  6163. return -EBUSY;
  6164. total = to_ratio(period, runtime);
  6165. /*
  6166. * Nobody can have more than the global setting allows.
  6167. */
  6168. if (total > to_ratio(global_rt_period(), global_rt_runtime()))
  6169. return -EINVAL;
  6170. /*
  6171. * The sum of our children's runtime should not exceed our own.
  6172. */
  6173. list_for_each_entry_rcu(child, &tg->children, siblings) {
  6174. period = ktime_to_ns(child->rt_bandwidth.rt_period);
  6175. runtime = child->rt_bandwidth.rt_runtime;
  6176. if (child == d->tg) {
  6177. period = d->rt_period;
  6178. runtime = d->rt_runtime;
  6179. }
  6180. sum += to_ratio(period, runtime);
  6181. }
  6182. if (sum > total)
  6183. return -EINVAL;
  6184. return 0;
  6185. }
  6186. static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)
  6187. {
  6188. int ret;
  6189. struct rt_schedulable_data data = {
  6190. .tg = tg,
  6191. .rt_period = period,
  6192. .rt_runtime = runtime,
  6193. };
  6194. rcu_read_lock();
  6195. ret = walk_tg_tree(tg_rt_schedulable, tg_nop, &data);
  6196. rcu_read_unlock();
  6197. return ret;
  6198. }
  6199. static int tg_set_rt_bandwidth(struct task_group *tg,
  6200. u64 rt_period, u64 rt_runtime)
  6201. {
  6202. int i, err = 0;
  6203. mutex_lock(&rt_constraints_mutex);
  6204. read_lock(&tasklist_lock);
  6205. err = __rt_schedulable(tg, rt_period, rt_runtime);
  6206. if (err)
  6207. goto unlock;
  6208. raw_spin_lock_irq(&tg->rt_bandwidth.rt_runtime_lock);
  6209. tg->rt_bandwidth.rt_period = ns_to_ktime(rt_period);
  6210. tg->rt_bandwidth.rt_runtime = rt_runtime;
  6211. for_each_possible_cpu(i) {
  6212. struct rt_rq *rt_rq = tg->rt_rq[i];
  6213. raw_spin_lock(&rt_rq->rt_runtime_lock);
  6214. rt_rq->rt_runtime = rt_runtime;
  6215. raw_spin_unlock(&rt_rq->rt_runtime_lock);
  6216. }
  6217. raw_spin_unlock_irq(&tg->rt_bandwidth.rt_runtime_lock);
  6218. unlock:
  6219. read_unlock(&tasklist_lock);
  6220. mutex_unlock(&rt_constraints_mutex);
  6221. return err;
  6222. }
  6223. int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us)
  6224. {
  6225. u64 rt_runtime, rt_period;
  6226. rt_period = ktime_to_ns(tg->rt_bandwidth.rt_period);
  6227. rt_runtime = (u64)rt_runtime_us * NSEC_PER_USEC;
  6228. if (rt_runtime_us < 0)
  6229. rt_runtime = RUNTIME_INF;
  6230. return tg_set_rt_bandwidth(tg, rt_period, rt_runtime);
  6231. }
  6232. long sched_group_rt_runtime(struct task_group *tg)
  6233. {
  6234. u64 rt_runtime_us;
  6235. if (tg->rt_bandwidth.rt_runtime == RUNTIME_INF)
  6236. return -1;
  6237. rt_runtime_us = tg->rt_bandwidth.rt_runtime;
  6238. do_div(rt_runtime_us, NSEC_PER_USEC);
  6239. return rt_runtime_us;
  6240. }
  6241. int sched_group_set_rt_period(struct task_group *tg, long rt_period_us)
  6242. {
  6243. u64 rt_runtime, rt_period;
  6244. rt_period = (u64)rt_period_us * NSEC_PER_USEC;
  6245. rt_runtime = tg->rt_bandwidth.rt_runtime;
  6246. if (rt_period == 0)
  6247. return -EINVAL;
  6248. return tg_set_rt_bandwidth(tg, rt_period, rt_runtime);
  6249. }
  6250. long sched_group_rt_period(struct task_group *tg)
  6251. {
  6252. u64 rt_period_us;
  6253. rt_period_us = ktime_to_ns(tg->rt_bandwidth.rt_period);
  6254. do_div(rt_period_us, NSEC_PER_USEC);
  6255. return rt_period_us;
  6256. }
  6257. static int sched_rt_global_constraints(void)
  6258. {
  6259. u64 runtime, period;
  6260. int ret = 0;
  6261. if (sysctl_sched_rt_period <= 0)
  6262. return -EINVAL;
  6263. runtime = global_rt_runtime();
  6264. period = global_rt_period();
  6265. /*
  6266. * Sanity check on the sysctl variables.
  6267. */
  6268. if (runtime > period && runtime != RUNTIME_INF)
  6269. return -EINVAL;
  6270. mutex_lock(&rt_constraints_mutex);
  6271. read_lock(&tasklist_lock);
  6272. ret = __rt_schedulable(NULL, 0, 0);
  6273. read_unlock(&tasklist_lock);
  6274. mutex_unlock(&rt_constraints_mutex);
  6275. return ret;
  6276. }
  6277. int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk)
  6278. {
  6279. /* Don't accept realtime tasks when there is no way for them to run */
  6280. if (rt_task(tsk) && tg->rt_bandwidth.rt_runtime == 0)
  6281. return 0;
  6282. return 1;
  6283. }
  6284. #else /* !CONFIG_RT_GROUP_SCHED */
  6285. static int sched_rt_global_constraints(void)
  6286. {
  6287. unsigned long flags;
  6288. int i;
  6289. if (sysctl_sched_rt_period <= 0)
  6290. return -EINVAL;
  6291. /*
  6292. * There's always some RT tasks in the root group
  6293. * -- migration, kstopmachine etc..
  6294. */
  6295. if (sysctl_sched_rt_runtime == 0)
  6296. return -EBUSY;
  6297. raw_spin_lock_irqsave(&def_rt_bandwidth.rt_runtime_lock, flags);
  6298. for_each_possible_cpu(i) {
  6299. struct rt_rq *rt_rq = &cpu_rq(i)->rt;
  6300. raw_spin_lock(&rt_rq->rt_runtime_lock);
  6301. rt_rq->rt_runtime = global_rt_runtime();
  6302. raw_spin_unlock(&rt_rq->rt_runtime_lock);
  6303. }
  6304. raw_spin_unlock_irqrestore(&def_rt_bandwidth.rt_runtime_lock, flags);
  6305. return 0;
  6306. }
  6307. #endif /* CONFIG_RT_GROUP_SCHED */
  6308. int sched_rt_handler(struct ctl_table *table, int write,
  6309. void __user *buffer, size_t *lenp,
  6310. loff_t *ppos)
  6311. {
  6312. int ret;
  6313. int old_period, old_runtime;
  6314. static DEFINE_MUTEX(mutex);
  6315. mutex_lock(&mutex);
  6316. old_period = sysctl_sched_rt_period;
  6317. old_runtime = sysctl_sched_rt_runtime;
  6318. ret = proc_dointvec(table, write, buffer, lenp, ppos);
  6319. if (!ret && write) {
  6320. ret = sched_rt_global_constraints();
  6321. if (ret) {
  6322. sysctl_sched_rt_period = old_period;
  6323. sysctl_sched_rt_runtime = old_runtime;
  6324. } else {
  6325. def_rt_bandwidth.rt_runtime = global_rt_runtime();
  6326. def_rt_bandwidth.rt_period =
  6327. ns_to_ktime(global_rt_period());
  6328. }
  6329. }
  6330. mutex_unlock(&mutex);
  6331. return ret;
  6332. }
  6333. #ifdef CONFIG_CGROUP_SCHED
  6334. /* return corresponding task_group object of a cgroup */
  6335. static inline struct task_group *cgroup_tg(struct cgroup *cgrp)
  6336. {
  6337. return container_of(cgroup_subsys_state(cgrp, cpu_cgroup_subsys_id),
  6338. struct task_group, css);
  6339. }
  6340. static struct cgroup_subsys_state *cpu_cgroup_create(struct cgroup *cgrp)
  6341. {
  6342. struct task_group *tg, *parent;
  6343. if (!cgrp->parent) {
  6344. /* This is early initialization for the top cgroup */
  6345. return &root_task_group.css;
  6346. }
  6347. parent = cgroup_tg(cgrp->parent);
  6348. tg = sched_create_group(parent);
  6349. if (IS_ERR(tg))
  6350. return ERR_PTR(-ENOMEM);
  6351. return &tg->css;
  6352. }
  6353. static void cpu_cgroup_destroy(struct cgroup *cgrp)
  6354. {
  6355. struct task_group *tg = cgroup_tg(cgrp);
  6356. sched_destroy_group(tg);
  6357. }
  6358. static int cpu_cgroup_can_attach(struct cgroup *cgrp,
  6359. struct cgroup_taskset *tset)
  6360. {
  6361. struct task_struct *task;
  6362. cgroup_taskset_for_each(task, cgrp, tset) {
  6363. #ifdef CONFIG_RT_GROUP_SCHED
  6364. if (!sched_rt_can_attach(cgroup_tg(cgrp), task))
  6365. return -EINVAL;
  6366. #else
  6367. /* We don't support RT-tasks being in separate groups */
  6368. if (task->sched_class != &fair_sched_class)
  6369. return -EINVAL;
  6370. #endif
  6371. }
  6372. return 0;
  6373. }
  6374. static void cpu_cgroup_attach(struct cgroup *cgrp,
  6375. struct cgroup_taskset *tset)
  6376. {
  6377. struct task_struct *task;
  6378. cgroup_taskset_for_each(task, cgrp, tset)
  6379. sched_move_task(task);
  6380. }
  6381. static void
  6382. cpu_cgroup_exit(struct cgroup *cgrp, struct cgroup *old_cgrp,
  6383. struct task_struct *task)
  6384. {
  6385. /*
  6386. * cgroup_exit() is called in the copy_process() failure path.
  6387. * Ignore this case since the task hasn't ran yet, this avoids
  6388. * trying to poke a half freed task state from generic code.
  6389. */
  6390. if (!(task->flags & PF_EXITING))
  6391. return;
  6392. sched_move_task(task);
  6393. }
  6394. #ifdef CONFIG_FAIR_GROUP_SCHED
  6395. static int cpu_shares_write_u64(struct cgroup *cgrp, struct cftype *cftype,
  6396. u64 shareval)
  6397. {
  6398. return sched_group_set_shares(cgroup_tg(cgrp), scale_load(shareval));
  6399. }
  6400. static u64 cpu_shares_read_u64(struct cgroup *cgrp, struct cftype *cft)
  6401. {
  6402. struct task_group *tg = cgroup_tg(cgrp);
  6403. return (u64) scale_load_down(tg->shares);
  6404. }
  6405. #ifdef CONFIG_CFS_BANDWIDTH
  6406. static DEFINE_MUTEX(cfs_constraints_mutex);
  6407. const u64 max_cfs_quota_period = 1 * NSEC_PER_SEC; /* 1s */
  6408. const u64 min_cfs_quota_period = 1 * NSEC_PER_MSEC; /* 1ms */
  6409. static int __cfs_schedulable(struct task_group *tg, u64 period, u64 runtime);
  6410. static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)
  6411. {
  6412. int i, ret = 0, runtime_enabled, runtime_was_enabled;
  6413. struct cfs_bandwidth *cfs_b = &tg->cfs_bandwidth;
  6414. if (tg == &root_task_group)
  6415. return -EINVAL;
  6416. /*
  6417. * Ensure we have at some amount of bandwidth every period. This is
  6418. * to prevent reaching a state of large arrears when throttled via
  6419. * entity_tick() resulting in prolonged exit starvation.
  6420. */
  6421. if (quota < min_cfs_quota_period || period < min_cfs_quota_period)
  6422. return -EINVAL;
  6423. /*
  6424. * Likewise, bound things on the otherside by preventing insane quota
  6425. * periods. This also allows us to normalize in computing quota
  6426. * feasibility.
  6427. */
  6428. if (period > max_cfs_quota_period)
  6429. return -EINVAL;
  6430. mutex_lock(&cfs_constraints_mutex);
  6431. ret = __cfs_schedulable(tg, period, quota);
  6432. if (ret)
  6433. goto out_unlock;
  6434. runtime_enabled = quota != RUNTIME_INF;
  6435. runtime_was_enabled = cfs_b->quota != RUNTIME_INF;
  6436. account_cfs_bandwidth_used(runtime_enabled, runtime_was_enabled);
  6437. raw_spin_lock_irq(&cfs_b->lock);
  6438. cfs_b->period = ns_to_ktime(period);
  6439. cfs_b->quota = quota;
  6440. __refill_cfs_bandwidth_runtime(cfs_b);
  6441. /* restart the period timer (if active) to handle new period expiry */
  6442. if (runtime_enabled && cfs_b->timer_active) {
  6443. /* force a reprogram */
  6444. cfs_b->timer_active = 0;
  6445. __start_cfs_bandwidth(cfs_b);
  6446. }
  6447. raw_spin_unlock_irq(&cfs_b->lock);
  6448. for_each_possible_cpu(i) {
  6449. struct cfs_rq *cfs_rq = tg->cfs_rq[i];
  6450. struct rq *rq = cfs_rq->rq;
  6451. raw_spin_lock_irq(&rq->lock);
  6452. cfs_rq->runtime_enabled = runtime_enabled;
  6453. cfs_rq->runtime_remaining = 0;
  6454. if (cfs_rq->throttled)
  6455. unthrottle_cfs_rq(cfs_rq);
  6456. raw_spin_unlock_irq(&rq->lock);
  6457. }
  6458. out_unlock:
  6459. mutex_unlock(&cfs_constraints_mutex);
  6460. return ret;
  6461. }
  6462. int tg_set_cfs_quota(struct task_group *tg, long cfs_quota_us)
  6463. {
  6464. u64 quota, period;
  6465. period = ktime_to_ns(tg->cfs_bandwidth.period);
  6466. if (cfs_quota_us < 0)
  6467. quota = RUNTIME_INF;
  6468. else
  6469. quota = (u64)cfs_quota_us * NSEC_PER_USEC;
  6470. return tg_set_cfs_bandwidth(tg, period, quota);
  6471. }
  6472. long tg_get_cfs_quota(struct task_group *tg)
  6473. {
  6474. u64 quota_us;
  6475. if (tg->cfs_bandwidth.quota == RUNTIME_INF)
  6476. return -1;
  6477. quota_us = tg->cfs_bandwidth.quota;
  6478. do_div(quota_us, NSEC_PER_USEC);
  6479. return quota_us;
  6480. }
  6481. int tg_set_cfs_period(struct task_group *tg, long cfs_period_us)
  6482. {
  6483. u64 quota, period;
  6484. period = (u64)cfs_period_us * NSEC_PER_USEC;
  6485. quota = tg->cfs_bandwidth.quota;
  6486. return tg_set_cfs_bandwidth(tg, period, quota);
  6487. }
  6488. long tg_get_cfs_period(struct task_group *tg)
  6489. {
  6490. u64 cfs_period_us;
  6491. cfs_period_us = ktime_to_ns(tg->cfs_bandwidth.period);
  6492. do_div(cfs_period_us, NSEC_PER_USEC);
  6493. return cfs_period_us;
  6494. }
  6495. static s64 cpu_cfs_quota_read_s64(struct cgroup *cgrp, struct cftype *cft)
  6496. {
  6497. return tg_get_cfs_quota(cgroup_tg(cgrp));
  6498. }
  6499. static int cpu_cfs_quota_write_s64(struct cgroup *cgrp, struct cftype *cftype,
  6500. s64 cfs_quota_us)
  6501. {
  6502. return tg_set_cfs_quota(cgroup_tg(cgrp), cfs_quota_us);
  6503. }
  6504. static u64 cpu_cfs_period_read_u64(struct cgroup *cgrp, struct cftype *cft)
  6505. {
  6506. return tg_get_cfs_period(cgroup_tg(cgrp));
  6507. }
  6508. static int cpu_cfs_period_write_u64(struct cgroup *cgrp, struct cftype *cftype,
  6509. u64 cfs_period_us)
  6510. {
  6511. return tg_set_cfs_period(cgroup_tg(cgrp), cfs_period_us);
  6512. }
  6513. struct cfs_schedulable_data {
  6514. struct task_group *tg;
  6515. u64 period, quota;
  6516. };
  6517. /*
  6518. * normalize group quota/period to be quota/max_period
  6519. * note: units are usecs
  6520. */
  6521. static u64 normalize_cfs_quota(struct task_group *tg,
  6522. struct cfs_schedulable_data *d)
  6523. {
  6524. u64 quota, period;
  6525. if (tg == d->tg) {
  6526. period = d->period;
  6527. quota = d->quota;
  6528. } else {
  6529. period = tg_get_cfs_period(tg);
  6530. quota = tg_get_cfs_quota(tg);
  6531. }
  6532. /* note: these should typically be equivalent */
  6533. if (quota == RUNTIME_INF || quota == -1)
  6534. return RUNTIME_INF;
  6535. return to_ratio(period, quota);
  6536. }
  6537. static int tg_cfs_schedulable_down(struct task_group *tg, void *data)
  6538. {
  6539. struct cfs_schedulable_data *d = data;
  6540. struct cfs_bandwidth *cfs_b = &tg->cfs_bandwidth;
  6541. s64 quota = 0, parent_quota = -1;
  6542. if (!tg->parent) {
  6543. quota = RUNTIME_INF;
  6544. } else {
  6545. struct cfs_bandwidth *parent_b = &tg->parent->cfs_bandwidth;
  6546. quota = normalize_cfs_quota(tg, d);
  6547. parent_quota = parent_b->hierarchal_quota;
  6548. /*
  6549. * ensure max(child_quota) <= parent_quota, inherit when no
  6550. * limit is set
  6551. */
  6552. if (quota == RUNTIME_INF)
  6553. quota = parent_quota;
  6554. else if (parent_quota != RUNTIME_INF && quota > parent_quota)
  6555. return -EINVAL;
  6556. }
  6557. cfs_b->hierarchal_quota = quota;
  6558. return 0;
  6559. }
  6560. static int __cfs_schedulable(struct task_group *tg, u64 period, u64 quota)
  6561. {
  6562. int ret;
  6563. struct cfs_schedulable_data data = {
  6564. .tg = tg,
  6565. .period = period,
  6566. .quota = quota,
  6567. };
  6568. if (quota != RUNTIME_INF) {
  6569. do_div(data.period, NSEC_PER_USEC);
  6570. do_div(data.quota, NSEC_PER_USEC);
  6571. }
  6572. rcu_read_lock();
  6573. ret = walk_tg_tree(tg_cfs_schedulable_down, tg_nop, &data);
  6574. rcu_read_unlock();
  6575. return ret;
  6576. }
  6577. static int cpu_stats_show(struct cgroup *cgrp, struct cftype *cft,
  6578. struct cgroup_map_cb *cb)
  6579. {
  6580. struct task_group *tg = cgroup_tg(cgrp);
  6581. struct cfs_bandwidth *cfs_b = &tg->cfs_bandwidth;
  6582. cb->fill(cb, "nr_periods", cfs_b->nr_periods);
  6583. cb->fill(cb, "nr_throttled", cfs_b->nr_throttled);
  6584. cb->fill(cb, "throttled_time", cfs_b->throttled_time);
  6585. return 0;
  6586. }
  6587. #endif /* CONFIG_CFS_BANDWIDTH */
  6588. #endif /* CONFIG_FAIR_GROUP_SCHED */
  6589. #ifdef CONFIG_RT_GROUP_SCHED
  6590. static int cpu_rt_runtime_write(struct cgroup *cgrp, struct cftype *cft,
  6591. s64 val)
  6592. {
  6593. return sched_group_set_rt_runtime(cgroup_tg(cgrp), val);
  6594. }
  6595. static s64 cpu_rt_runtime_read(struct cgroup *cgrp, struct cftype *cft)
  6596. {
  6597. return sched_group_rt_runtime(cgroup_tg(cgrp));
  6598. }
  6599. static int cpu_rt_period_write_uint(struct cgroup *cgrp, struct cftype *cftype,
  6600. u64 rt_period_us)
  6601. {
  6602. return sched_group_set_rt_period(cgroup_tg(cgrp), rt_period_us);
  6603. }
  6604. static u64 cpu_rt_period_read_uint(struct cgroup *cgrp, struct cftype *cft)
  6605. {
  6606. return sched_group_rt_period(cgroup_tg(cgrp));
  6607. }
  6608. #endif /* CONFIG_RT_GROUP_SCHED */
  6609. static struct cftype cpu_files[] = {
  6610. #ifdef CONFIG_FAIR_GROUP_SCHED
  6611. {
  6612. .name = "shares",
  6613. .read_u64 = cpu_shares_read_u64,
  6614. .write_u64 = cpu_shares_write_u64,
  6615. },
  6616. #endif
  6617. #ifdef CONFIG_CFS_BANDWIDTH
  6618. {
  6619. .name = "cfs_quota_us",
  6620. .read_s64 = cpu_cfs_quota_read_s64,
  6621. .write_s64 = cpu_cfs_quota_write_s64,
  6622. },
  6623. {
  6624. .name = "cfs_period_us",
  6625. .read_u64 = cpu_cfs_period_read_u64,
  6626. .write_u64 = cpu_cfs_period_write_u64,
  6627. },
  6628. {
  6629. .name = "stat",
  6630. .read_map = cpu_stats_show,
  6631. },
  6632. #endif
  6633. #ifdef CONFIG_RT_GROUP_SCHED
  6634. {
  6635. .name = "rt_runtime_us",
  6636. .read_s64 = cpu_rt_runtime_read,
  6637. .write_s64 = cpu_rt_runtime_write,
  6638. },
  6639. {
  6640. .name = "rt_period_us",
  6641. .read_u64 = cpu_rt_period_read_uint,
  6642. .write_u64 = cpu_rt_period_write_uint,
  6643. },
  6644. #endif
  6645. { } /* terminate */
  6646. };
  6647. struct cgroup_subsys cpu_cgroup_subsys = {
  6648. .name = "cpu",
  6649. .create = cpu_cgroup_create,
  6650. .destroy = cpu_cgroup_destroy,
  6651. .can_attach = cpu_cgroup_can_attach,
  6652. .attach = cpu_cgroup_attach,
  6653. .exit = cpu_cgroup_exit,
  6654. .subsys_id = cpu_cgroup_subsys_id,
  6655. .base_cftypes = cpu_files,
  6656. .early_init = 1,
  6657. };
  6658. #endif /* CONFIG_CGROUP_SCHED */
  6659. #ifdef CONFIG_CGROUP_CPUACCT
  6660. /*
  6661. * CPU accounting code for task groups.
  6662. *
  6663. * Based on the work by Paul Menage (menage@google.com) and Balbir Singh
  6664. * (balbir@in.ibm.com).
  6665. */
  6666. struct cpuacct root_cpuacct;
  6667. /* create a new cpu accounting group */
  6668. static struct cgroup_subsys_state *cpuacct_create(struct cgroup *cgrp)
  6669. {
  6670. struct cpuacct *ca;
  6671. if (!cgrp->parent)
  6672. return &root_cpuacct.css;
  6673. ca = kzalloc(sizeof(*ca), GFP_KERNEL);
  6674. if (!ca)
  6675. goto out;
  6676. ca->cpuusage = alloc_percpu(u64);
  6677. if (!ca->cpuusage)
  6678. goto out_free_ca;
  6679. ca->cpustat = alloc_percpu(struct kernel_cpustat);
  6680. if (!ca->cpustat)
  6681. goto out_free_cpuusage;
  6682. return &ca->css;
  6683. out_free_cpuusage:
  6684. free_percpu(ca->cpuusage);
  6685. out_free_ca:
  6686. kfree(ca);
  6687. out:
  6688. return ERR_PTR(-ENOMEM);
  6689. }
  6690. /* destroy an existing cpu accounting group */
  6691. static void cpuacct_destroy(struct cgroup *cgrp)
  6692. {
  6693. struct cpuacct *ca = cgroup_ca(cgrp);
  6694. free_percpu(ca->cpustat);
  6695. free_percpu(ca->cpuusage);
  6696. kfree(ca);
  6697. }
  6698. static u64 cpuacct_cpuusage_read(struct cpuacct *ca, int cpu)
  6699. {
  6700. u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
  6701. u64 data;
  6702. #ifndef CONFIG_64BIT
  6703. /*
  6704. * Take rq->lock to make 64-bit read safe on 32-bit platforms.
  6705. */
  6706. raw_spin_lock_irq(&cpu_rq(cpu)->lock);
  6707. data = *cpuusage;
  6708. raw_spin_unlock_irq(&cpu_rq(cpu)->lock);
  6709. #else
  6710. data = *cpuusage;
  6711. #endif
  6712. return data;
  6713. }
  6714. static void cpuacct_cpuusage_write(struct cpuacct *ca, int cpu, u64 val)
  6715. {
  6716. u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
  6717. #ifndef CONFIG_64BIT
  6718. /*
  6719. * Take rq->lock to make 64-bit write safe on 32-bit platforms.
  6720. */
  6721. raw_spin_lock_irq(&cpu_rq(cpu)->lock);
  6722. *cpuusage = val;
  6723. raw_spin_unlock_irq(&cpu_rq(cpu)->lock);
  6724. #else
  6725. *cpuusage = val;
  6726. #endif
  6727. }
  6728. /* return total cpu usage (in nanoseconds) of a group */
  6729. static u64 cpuusage_read(struct cgroup *cgrp, struct cftype *cft)
  6730. {
  6731. struct cpuacct *ca = cgroup_ca(cgrp);
  6732. u64 totalcpuusage = 0;
  6733. int i;
  6734. for_each_present_cpu(i)
  6735. totalcpuusage += cpuacct_cpuusage_read(ca, i);
  6736. return totalcpuusage;
  6737. }
  6738. static int cpuusage_write(struct cgroup *cgrp, struct cftype *cftype,
  6739. u64 reset)
  6740. {
  6741. struct cpuacct *ca = cgroup_ca(cgrp);
  6742. int err = 0;
  6743. int i;
  6744. if (reset) {
  6745. err = -EINVAL;
  6746. goto out;
  6747. }
  6748. for_each_present_cpu(i)
  6749. cpuacct_cpuusage_write(ca, i, 0);
  6750. out:
  6751. return err;
  6752. }
  6753. static int cpuacct_percpu_seq_read(struct cgroup *cgroup, struct cftype *cft,
  6754. struct seq_file *m)
  6755. {
  6756. struct cpuacct *ca = cgroup_ca(cgroup);
  6757. u64 percpu;
  6758. int i;
  6759. for_each_present_cpu(i) {
  6760. percpu = cpuacct_cpuusage_read(ca, i);
  6761. seq_printf(m, "%llu ", (unsigned long long) percpu);
  6762. }
  6763. seq_printf(m, "\n");
  6764. return 0;
  6765. }
  6766. static const char *cpuacct_stat_desc[] = {
  6767. [CPUACCT_STAT_USER] = "user",
  6768. [CPUACCT_STAT_SYSTEM] = "system",
  6769. };
  6770. static int cpuacct_stats_show(struct cgroup *cgrp, struct cftype *cft,
  6771. struct cgroup_map_cb *cb)
  6772. {
  6773. struct cpuacct *ca = cgroup_ca(cgrp);
  6774. int cpu;
  6775. s64 val = 0;
  6776. for_each_online_cpu(cpu) {
  6777. struct kernel_cpustat *kcpustat = per_cpu_ptr(ca->cpustat, cpu);
  6778. val += kcpustat->cpustat[CPUTIME_USER];
  6779. val += kcpustat->cpustat[CPUTIME_NICE];
  6780. }
  6781. val = cputime64_to_clock_t(val);
  6782. cb->fill(cb, cpuacct_stat_desc[CPUACCT_STAT_USER], val);
  6783. val = 0;
  6784. for_each_online_cpu(cpu) {
  6785. struct kernel_cpustat *kcpustat = per_cpu_ptr(ca->cpustat, cpu);
  6786. val += kcpustat->cpustat[CPUTIME_SYSTEM];
  6787. val += kcpustat->cpustat[CPUTIME_IRQ];
  6788. val += kcpustat->cpustat[CPUTIME_SOFTIRQ];
  6789. }
  6790. val = cputime64_to_clock_t(val);
  6791. cb->fill(cb, cpuacct_stat_desc[CPUACCT_STAT_SYSTEM], val);
  6792. return 0;
  6793. }
  6794. static struct cftype files[] = {
  6795. {
  6796. .name = "usage",
  6797. .read_u64 = cpuusage_read,
  6798. .write_u64 = cpuusage_write,
  6799. },
  6800. {
  6801. .name = "usage_percpu",
  6802. .read_seq_string = cpuacct_percpu_seq_read,
  6803. },
  6804. {
  6805. .name = "stat",
  6806. .read_map = cpuacct_stats_show,
  6807. },
  6808. { } /* terminate */
  6809. };
  6810. /*
  6811. * charge this task's execution time to its accounting group.
  6812. *
  6813. * called with rq->lock held.
  6814. */
  6815. void cpuacct_charge(struct task_struct *tsk, u64 cputime)
  6816. {
  6817. struct cpuacct *ca;
  6818. int cpu;
  6819. if (unlikely(!cpuacct_subsys.active))
  6820. return;
  6821. cpu = task_cpu(tsk);
  6822. rcu_read_lock();
  6823. ca = task_ca(tsk);
  6824. for (; ca; ca = parent_ca(ca)) {
  6825. u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
  6826. *cpuusage += cputime;
  6827. }
  6828. rcu_read_unlock();
  6829. }
  6830. struct cgroup_subsys cpuacct_subsys = {
  6831. .name = "cpuacct",
  6832. .create = cpuacct_create,
  6833. .destroy = cpuacct_destroy,
  6834. .subsys_id = cpuacct_subsys_id,
  6835. .base_cftypes = files,
  6836. };
  6837. #endif /* CONFIG_CGROUP_CPUACCT */
  6838. void dump_cpu_task(int cpu)
  6839. {
  6840. pr_info("Task dump for CPU %d:\n", cpu);
  6841. sched_show_task(cpu_curr(cpu));
  6842. }