Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145614661476148614961506151615261536154615561566157615861596160616161626163616461656166616761686169617061716172617361746175617661776178617961806181618261836184618561866187618861896190619161926193619461956196619761986199620062016202620362046205620662076208620962106211621262136214621562166217621862196220622162226223622462256226622762286229623062316232623362346235623662376238623962406241624262436244624562466247624862496250625162526253625462556256625762586259626062616262626362646265626662676268626962706271627262736274627562766277627862796280628162826283628462856286628762886289629062916292629362946295629662976298629963006301630263036304630563066307630863096310631163126313631463156316631763186319632063216322632363246325632663276328632963306331633263336334633563366337633863396340634163426343634463456346634763486349635063516352635363546355635663576358635963606361636263636364636563666367636863696370637163726373637463756376637763786379638063816382638363846385638663876388638963906391639263936394639563966397639863996400640164026403640464056406640764086409641064116412641364146415641664176418641964206421642264236424642564266427642864296430643164326433643464356436643764386439644064416442644364446445644664476448644964506451645264536454645564566457645864596460646164626463646464656466646764686469647064716472647364746475647664776478647964806481648264836484648564866487648864896490649164926493649464956496649764986499650065016502650365046505650665076508650965106511651265136514651565166517651865196520652165226523652465256526652765286529653065316532653365346535653665376538653965406541654265436544654565466547654865496550655165526553655465556556655765586559656065616562656365646565656665676568656965706571657265736574657565766577657865796580658165826583658465856586658765886589659065916592659365946595659665976598659966006601660266036604660566066607660866096610661166126613661466156616661766186619662066216622662366246625662666276628662966306631663266336634663566366637663866396640664166426643664466456646664766486649665066516652665366546655665666576658665966606661666266636664666566666667666866696670667166726673667466756676667766786679668066816682668366846685668666876688668966906691669266936694669566966697669866996700670167026703670467056706670767086709671067116712671367146715671667176718671967206721672267236724672567266727672867296730673167326733673467356736673767386739674067416742674367446745674667476748674967506751675267536754675567566757675867596760676167626763676467656766676767686769677067716772677367746775677667776778677967806781678267836784678567866787678867896790679167926793679467956796679767986799680068016802680368046805680668076808680968106811681268136814681568166817681868196820682168226823682468256826682768286829683068316832683368346835683668376838683968406841684268436844684568466847684868496850685168526853685468556856685768586859686068616862686368646865686668676868686968706871687268736874687568766877687868796880688168826883688468856886688768886889689068916892689368946895689668976898689969006901690269036904690569066907690869096910691169126913691469156916691769186919692069216922692369246925692669276928692969306931693269336934693569366937693869396940694169426943694469456946694769486949695069516952695369546955695669576958695969606961696269636964696569666967696869696970697169726973697469756976697769786979698069816982698369846985698669876988698969906991699269936994699569966997699869997000700170027003700470057006700770087009701070117012701370147015701670177018701970207021702270237024702570267027702870297030703170327033703470357036703770387039704070417042704370447045704670477048704970507051705270537054705570567057705870597060706170627063706470657066706770687069707070717072707370747075707670777078707970807081708270837084708570867087708870897090709170927093709470957096709770987099710071017102710371047105710671077108710971107111711271137114711571167117711871197120712171227123712471257126712771287129713071317132713371347135713671377138713971407141714271437144714571467147714871497150715171527153715471557156715771587159716071617162716371647165716671677168716971707171717271737174717571767177717871797180718171827183718471857186718771887189719071917192719371947195719671977198719972007201720272037204720572067207720872097210721172127213721472157216721772187219722072217222722372247225722672277228722972307231723272337234723572367237723872397240724172427243724472457246724772487249725072517252725372547255725672577258725972607261726272637264726572667267726872697270727172727273727472757276727772787279728072817282728372847285728672877288728972907291729272937294729572967297729872997300730173027303730473057306730773087309731073117312731373147315731673177318731973207321732273237324732573267327732873297330733173327333733473357336733773387339734073417342734373447345734673477348734973507351735273537354735573567357735873597360736173627363736473657366736773687369737073717372737373747375737673777378737973807381738273837384738573867387738873897390739173927393739473957396739773987399740074017402740374047405740674077408740974107411741274137414741574167417741874197420742174227423742474257426742774287429743074317432743374347435743674377438743974407441744274437444744574467447744874497450745174527453745474557456745774587459746074617462746374647465746674677468746974707471747274737474747574767477747874797480748174827483748474857486748774887489749074917492749374947495749674977498749975007501750275037504750575067507750875097510751175127513751475157516751775187519752075217522752375247525752675277528752975307531753275337534753575367537753875397540754175427543754475457546754775487549755075517552755375547555755675577558755975607561756275637564756575667567756875697570757175727573757475757576757775787579758075817582758375847585758675877588758975907591759275937594759575967597759875997600760176027603760476057606760776087609761076117612761376147615761676177618761976207621762276237624762576267627762876297630763176327633763476357636763776387639764076417642764376447645764676477648764976507651765276537654765576567657765876597660766176627663766476657666766776687669767076717672767376747675767676777678767976807681768276837684768576867687768876897690769176927693769476957696769776987699770077017702770377047705770677077708770977107711771277137714771577167717771877197720772177227723772477257726772777287729773077317732773377347735773677377738773977407741774277437744774577467747774877497750775177527753775477557756775777587759776077617762776377647765776677677768776977707771777277737774777577767777777877797780778177827783778477857786778777887789779077917792779377947795779677977798779978007801780278037804780578067807780878097810781178127813781478157816781778187819782078217822782378247825782678277828782978307831783278337834783578367837783878397840784178427843784478457846784778487849785078517852785378547855785678577858785978607861786278637864786578667867786878697870787178727873787478757876787778787879788078817882788378847885788678877888788978907891789278937894789578967897789878997900790179027903790479057906790779087909791079117912791379147915791679177918791979207921792279237924792579267927792879297930793179327933793479357936793779387939794079417942794379447945794679477948794979507951795279537954795579567957795879597960796179627963796479657966796779687969797079717972797379747975797679777978797979807981798279837984798579867987798879897990799179927993799479957996799779987999800080018002800380048005800680078008800980108011801280138014801580168017801880198020802180228023802480258026802780288029803080318032803380348035803680378038803980408041804280438044804580468047804880498050805180528053805480558056805780588059806080618062806380648065806680678068806980708071807280738074807580768077807880798080808180828083808480858086808780888089809080918092809380948095809680978098809981008101810281038104810581068107810881098110811181128113811481158116811781188119812081218122812381248125812681278128812981308131813281338134813581368137813881398140814181428143814481458146814781488149815081518152815381548155815681578158815981608161816281638164816581668167816881698170817181728173817481758176817781788179818081818182818381848185818681878188818981908191819281938194819581968197819881998200820182028203820482058206820782088209821082118212821382148215821682178218821982208221822282238224822582268227822882298230823182328233823482358236823782388239824082418242824382448245824682478248824982508251825282538254825582568257825882598260826182628263826482658266826782688269827082718272827382748275827682778278827982808281828282838284828582868287828882898290829182928293829482958296829782988299830083018302830383048305830683078308830983108311831283138314831583168317831883198320832183228323832483258326832783288329833083318332833383348335833683378338833983408341834283438344834583468347834883498350835183528353835483558356835783588359836083618362836383648365836683678368836983708371837283738374837583768377837883798380838183828383838483858386838783888389839083918392839383948395839683978398839984008401840284038404840584068407840884098410841184128413841484158416841784188419842084218422842384248425842684278428842984308431843284338434843584368437843884398440844184428443844484458446844784488449845084518452845384548455845684578458845984608461846284638464846584668467846884698470847184728473847484758476847784788479848084818482848384848485848684878488848984908491849284938494849584968497849884998500850185028503850485058506850785088509851085118512851385148515851685178518851985208521852285238524852585268527852885298530853185328533853485358536853785388539854085418542854385448545854685478548854985508551855285538554855585568557855885598560856185628563856485658566856785688569857085718572857385748575857685778578857985808581858285838584858585868587858885898590859185928593859485958596859785988599860086018602860386048605860686078608860986108611861286138614861586168617861886198620862186228623862486258626862786288629863086318632863386348635863686378638863986408641864286438644864586468647864886498650865186528653865486558656865786588659866086618662866386648665866686678668866986708671867286738674867586768677867886798680868186828683868486858686868786888689869086918692869386948695869686978698869987008701870287038704870587068707870887098710871187128713871487158716871787188719872087218722872387248725872687278728872987308731873287338734873587368737873887398740874187428743874487458746874787488749875087518752875387548755875687578758875987608761876287638764876587668767876887698770877187728773877487758776877787788779878087818782878387848785878687878788878987908791879287938794879587968797879887998800880188028803880488058806880788088809881088118812881388148815881688178818881988208821882288238824882588268827882888298830883188328833883488358836883788388839884088418842884388448845884688478848884988508851885288538854885588568857885888598860886188628863886488658866886788688869887088718872887388748875887688778878887988808881888288838884888588868887888888898890889188928893889488958896889788988899890089018902890389048905890689078908890989108911891289138914891589168917891889198920892189228923892489258926892789288929893089318932893389348935893689378938893989408941894289438944894589468947894889498950895189528953895489558956895789588959896089618962896389648965896689678968896989708971897289738974897589768977897889798980898189828983898489858986898789888989899089918992899389948995899689978998899990009001900290039004900590069007900890099010901190129013901490159016901790189019902090219022902390249025902690279028902990309031903290339034903590369037903890399040904190429043904490459046904790489049905090519052905390549055905690579058905990609061906290639064906590669067906890699070907190729073907490759076907790789079908090819082908390849085908690879088908990909091909290939094909590969097909890999100910191029103910491059106910791089109911091119112911391149115911691179118911991209121912291239124912591269127912891299130913191329133913491359136913791389139914091419142914391449145914691479148914991509151915291539154915591569157915891599160916191629163916491659166916791689169917091719172917391749175917691779178917991809181918291839184918591869187918891899190919191929193919491959196919791989199920092019202920392049205920692079208920992109211921292139214921592169217921892199220922192229223922492259226922792289229923092319232923392349235923692379238923992409241924292439244924592469247924892499250925192529253925492559256925792589259926092619262926392649265926692679268926992709271927292739274927592769277927892799280928192829283928492859286928792889289929092919292929392949295929692979298929993009301930293039304930593069307930893099310931193129313931493159316931793189319932093219322932393249325932693279328932993309331933293339334933593369337933893399340934193429343934493459346934793489349935093519352935393549355935693579358935993609361936293639364936593669367936893699370937193729373937493759376937793789379938093819382938393849385938693879388938993909391939293939394939593969397939893999400940194029403940494059406940794089409941094119412941394149415941694179418941994209421942294239424942594269427942894299430943194329433943494359436943794389439944094419442944394449445944694479448944994509451945294539454945594569457945894599460946194629463// SPDX-License-Identifier: GPL-2.0/* * Infrastructure for profiling code inserted by 'gcc -pg'. * * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com> * Copyright (C) 2004-2008 Ingo Molnar <mingo@redhat.com> * * Originally ported from the -rt patch by: * Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com> * * Based on code in the latency_tracer, that is: * * Copyright (C) 2004-2006 Ingo Molnar * Copyright (C) 2004 Nadia Yvette Chambers */
#include <linux/stop_machine.h>#include <linux/clocksource.h>#include <linux/sched/task.h>#include <linux/kallsyms.h>#include <linux/security.h>#include <linux/seq_file.h>#include <linux/tracefs.h>#include <linux/hardirq.h>#include <linux/kthread.h>#include <linux/uaccess.h>#include <linux/bsearch.h>#include <linux/module.h>#include <linux/ftrace.h>#include <linux/sysctl.h>#include <linux/slab.h>#include <linux/ctype.h>#include <linux/sort.h>#include <linux/list.h>#include <linux/hash.h>#include <linux/rcupdate.h>#include <linux/kprobes.h>
#include <trace/events/sched.h>
#include <asm/sections.h>#include <asm/setup.h>
#include "ftrace_internal.h"#include "trace_output.h"#include "trace_stat.h"
/* Flags that do not get reset */#define FTRACE_NOCLEAR_FLAGS (FTRACE_FL_DISABLED | FTRACE_FL_TOUCHED | \ FTRACE_FL_MODIFIED)
#define FTRACE_INVALID_FUNCTION "__ftrace_invalid_address__"
#define FTRACE_WARN_ON(cond) \ ({ \ int ___r = cond; \ if (WARN_ON(___r)) \ ftrace_kill(); \ ___r; \ })
#define FTRACE_WARN_ON_ONCE(cond) \ ({ \ int ___r = cond; \ if (WARN_ON_ONCE(___r)) \ ftrace_kill(); \ ___r; \ })
/* hash bits for specific function selection */#define FTRACE_HASH_MAX_BITS 12
#ifdef CONFIG_DYNAMIC_FTRACE#define INIT_OPS_HASH(opsname) \ .func_hash = &opsname.local_hash, \ .local_hash.regex_lock = __MUTEX_INITIALIZER(opsname.local_hash.regex_lock), \ .subop_list = LIST_HEAD_INIT(opsname.subop_list),#else#define INIT_OPS_HASH(opsname)#endif
enum { FTRACE_MODIFY_ENABLE_FL = (1 << 0), FTRACE_MODIFY_MAY_SLEEP_FL = (1 << 1),};
struct ftrace_ops ftrace_list_end __read_mostly = { .func = ftrace_stub, .flags = FTRACE_OPS_FL_STUB, INIT_OPS_HASH(ftrace_list_end)};
/* ftrace_enabled is a method to turn ftrace on or off */int ftrace_enabled __read_mostly;static int __maybe_unused last_ftrace_enabled;
/* Current function tracing op */struct ftrace_ops *function_trace_op __read_mostly = &ftrace_list_end;/* What to set function_trace_op to */static struct ftrace_ops *set_function_trace_op;
bool ftrace_pids_enabled(struct ftrace_ops *ops){ struct trace_array *tr;
if (!(ops->flags & FTRACE_OPS_FL_PID) || !ops->private) return false;
tr = ops->private;
return tr->function_pids != NULL || tr->function_no_pids != NULL;}
static void ftrace_update_trampoline(struct ftrace_ops *ops);
/* * ftrace_disabled is set when an anomaly is discovered. * ftrace_disabled is much stronger than ftrace_enabled. */static int ftrace_disabled __read_mostly;
DEFINE_MUTEX(ftrace_lock);
struct ftrace_ops __rcu *ftrace_ops_list __read_mostly = (struct ftrace_ops __rcu *)&ftrace_list_end;ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;struct ftrace_ops global_ops;
/* Defined by vmlinux.lds.h see the comment above arch_ftrace_ops_list_func for details */void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct ftrace_regs *fregs);
#ifdef CONFIG_DYNAMIC_FTRACE_WITH_CALL_OPS/* * Stub used to invoke the list ops without requiring a separate trampoline. */const struct ftrace_ops ftrace_list_ops = { .func = ftrace_ops_list_func, .flags = FTRACE_OPS_FL_STUB,};
static void ftrace_ops_nop_func(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct ftrace_regs *fregs){ /* do nothing */}
/* * Stub used when a call site is disabled. May be called transiently by threads * which have made it into ftrace_caller but haven't yet recovered the ops at * the point the call site is disabled. */const struct ftrace_ops ftrace_nop_ops = { .func = ftrace_ops_nop_func, .flags = FTRACE_OPS_FL_STUB,};#endif
static inline void ftrace_ops_init(struct ftrace_ops *ops){#ifdef CONFIG_DYNAMIC_FTRACE if (!(ops->flags & FTRACE_OPS_FL_INITIALIZED)) { mutex_init(&ops->local_hash.regex_lock); INIT_LIST_HEAD(&ops->subop_list); ops->func_hash = &ops->local_hash; ops->flags |= FTRACE_OPS_FL_INITIALIZED; }#endif}
/* Call this function for when a callback filters on set_ftrace_pid */static void ftrace_pid_func(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct ftrace_regs *fregs){ struct trace_array *tr = op->private; int pid;
if (tr) { pid = this_cpu_read(tr->array_buffer.data->ftrace_ignore_pid); if (pid == FTRACE_PID_IGNORE) return; if (pid != FTRACE_PID_TRACE && pid != current->pid) return; }
op->saved_func(ip, parent_ip, op, fregs);}
void ftrace_sync_ipi(void *data){ /* Probably not needed, but do it anyway */ smp_rmb();}
static ftrace_func_t ftrace_ops_get_list_func(struct ftrace_ops *ops){ /* * If this is a dynamic or RCU ops, or we force list func, * then it needs to call the list anyway. */ if (ops->flags & (FTRACE_OPS_FL_DYNAMIC | FTRACE_OPS_FL_RCU) || FTRACE_FORCE_LIST_FUNC) return ftrace_ops_list_func;
return ftrace_ops_get_func(ops);}
static void update_ftrace_function(void){ ftrace_func_t func;
/* * Prepare the ftrace_ops that the arch callback will use. * If there's only one ftrace_ops registered, the ftrace_ops_list * will point to the ops we want. */ set_function_trace_op = rcu_dereference_protected(ftrace_ops_list, lockdep_is_held(&ftrace_lock));
/* If there's no ftrace_ops registered, just call the stub function */ if (set_function_trace_op == &ftrace_list_end) { func = ftrace_stub;
/* * If we are at the end of the list and this ops is * recursion safe and not dynamic and the arch supports passing ops, * then have the mcount trampoline call the function directly. */ } else if (rcu_dereference_protected(ftrace_ops_list->next, lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) { func = ftrace_ops_get_list_func(ftrace_ops_list);
} else { /* Just use the default ftrace_ops */ set_function_trace_op = &ftrace_list_end; func = ftrace_ops_list_func; }
/* If there's no change, then do nothing more here */ if (ftrace_trace_function == func) return;
/* * If we are using the list function, it doesn't care * about the function_trace_ops. */ if (func == ftrace_ops_list_func) { ftrace_trace_function = func; /* * Don't even bother setting function_trace_ops, * it would be racy to do so anyway. */ return; }
#ifndef CONFIG_DYNAMIC_FTRACE /* * For static tracing, we need to be a bit more careful. * The function change takes affect immediately. Thus, * we need to coordinate the setting of the function_trace_ops * with the setting of the ftrace_trace_function. * * Set the function to the list ops, which will call the * function we want, albeit indirectly, but it handles the * ftrace_ops and doesn't depend on function_trace_op. */ ftrace_trace_function = ftrace_ops_list_func; /* * Make sure all CPUs see this. Yes this is slow, but static * tracing is slow and nasty to have enabled. */ synchronize_rcu_tasks_rude(); /* Now all cpus are using the list ops. */ function_trace_op = set_function_trace_op; /* Make sure the function_trace_op is visible on all CPUs */ smp_wmb(); /* Nasty way to force a rmb on all cpus */ smp_call_function(ftrace_sync_ipi, NULL, 1); /* OK, we are all set to update the ftrace_trace_function now! */#endif /* !CONFIG_DYNAMIC_FTRACE */
ftrace_trace_function = func;}
static void add_ftrace_ops(struct ftrace_ops __rcu **list, struct ftrace_ops *ops){ rcu_assign_pointer(ops->next, *list);
/* * We are entering ops into the list but another * CPU might be walking that list. We need to make sure * the ops->next pointer is valid before another CPU sees * the ops pointer included into the list. */ rcu_assign_pointer(*list, ops);}
static int remove_ftrace_ops(struct ftrace_ops __rcu **list, struct ftrace_ops *ops){ struct ftrace_ops **p;
/* * If we are removing the last function, then simply point * to the ftrace_stub. */ if (rcu_dereference_protected(*list, lockdep_is_held(&ftrace_lock)) == ops && rcu_dereference_protected(ops->next, lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) { rcu_assign_pointer(*list, &ftrace_list_end); return 0; }
for (p = list; *p != &ftrace_list_end; p = &(*p)->next) if (*p == ops) break;
if (*p != ops) return -1;
*p = (*p)->next; return 0;}
static void ftrace_update_trampoline(struct ftrace_ops *ops);
int __register_ftrace_function(struct ftrace_ops *ops){ if (ops->flags & FTRACE_OPS_FL_DELETED) return -EINVAL;
if (WARN_ON(ops->flags & FTRACE_OPS_FL_ENABLED)) return -EBUSY;
#ifndef CONFIG_DYNAMIC_FTRACE_WITH_REGS /* * If the ftrace_ops specifies SAVE_REGS, then it only can be used * if the arch supports it, or SAVE_REGS_IF_SUPPORTED is also set. * Setting SAVE_REGS_IF_SUPPORTED makes SAVE_REGS irrelevant. */ if (ops->flags & FTRACE_OPS_FL_SAVE_REGS && !(ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED)) return -EINVAL;
if (ops->flags & FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED) ops->flags |= FTRACE_OPS_FL_SAVE_REGS;#endif if (!ftrace_enabled && (ops->flags & FTRACE_OPS_FL_PERMANENT)) return -EBUSY;
if (!is_kernel_core_data((unsigned long)ops)) ops->flags |= FTRACE_OPS_FL_DYNAMIC;
add_ftrace_ops(&ftrace_ops_list, ops);
/* Always save the function, and reset at unregistering */ ops->saved_func = ops->func;
if (ftrace_pids_enabled(ops)) ops->func = ftrace_pid_func;
ftrace_update_trampoline(ops);
if (ftrace_enabled) update_ftrace_function();
return 0;}
int __unregister_ftrace_function(struct ftrace_ops *ops){ int ret;
if (WARN_ON(!(ops->flags & FTRACE_OPS_FL_ENABLED))) return -EBUSY;
ret = remove_ftrace_ops(&ftrace_ops_list, ops);
if (ret < 0) return ret;
if (ftrace_enabled) update_ftrace_function();
ops->func = ops->saved_func;
return 0;}
static void ftrace_update_pid_func(void){ struct ftrace_ops *op;
/* Only do something if we are tracing something */ if (ftrace_trace_function == ftrace_stub) return;
do_for_each_ftrace_op(op, ftrace_ops_list) { if (op->flags & FTRACE_OPS_FL_PID) { op->func = ftrace_pids_enabled(op) ? ftrace_pid_func : op->saved_func; ftrace_update_trampoline(op); } } while_for_each_ftrace_op(op);
fgraph_update_pid_func();
update_ftrace_function();}
#ifdef CONFIG_FUNCTION_PROFILERstruct ftrace_profile { struct hlist_node node; unsigned long ip; unsigned long counter;#ifdef CONFIG_FUNCTION_GRAPH_TRACER unsigned long long time; unsigned long long time_squared;#endif};
struct ftrace_profile_page { struct ftrace_profile_page *next; unsigned long index; struct ftrace_profile records[];};
struct ftrace_profile_stat { atomic_t disabled; struct hlist_head *hash; struct ftrace_profile_page *pages; struct ftrace_profile_page *start; struct tracer_stat stat;};
#define PROFILE_RECORDS_SIZE \ (PAGE_SIZE - offsetof(struct ftrace_profile_page, records))
#define PROFILES_PER_PAGE \ (PROFILE_RECORDS_SIZE / sizeof(struct ftrace_profile))
static int ftrace_profile_enabled __read_mostly;
/* ftrace_profile_lock - synchronize the enable and disable of the profiler */static DEFINE_MUTEX(ftrace_profile_lock);
static DEFINE_PER_CPU(struct ftrace_profile_stat, ftrace_profile_stats);
#define FTRACE_PROFILE_HASH_BITS 10#define FTRACE_PROFILE_HASH_SIZE (1 << FTRACE_PROFILE_HASH_BITS)
static void *function_stat_next(void *v, int idx){ struct ftrace_profile *rec = v; struct ftrace_profile_page *pg;
pg = (struct ftrace_profile_page *)((unsigned long)rec & PAGE_MASK);
again: if (idx != 0) rec++;
if ((void *)rec >= (void *)&pg->records[pg->index]) { pg = pg->next; if (!pg) return NULL; rec = &pg->records[0]; if (!rec->counter) goto again; }
return rec;}
static void *function_stat_start(struct tracer_stat *trace){ struct ftrace_profile_stat *stat = container_of(trace, struct ftrace_profile_stat, stat);
if (!stat || !stat->start) return NULL;
return function_stat_next(&stat->start->records[0], 0);}
#ifdef CONFIG_FUNCTION_GRAPH_TRACER/* function graph compares on total time */static int function_stat_cmp(const void *p1, const void *p2){ const struct ftrace_profile *a = p1; const struct ftrace_profile *b = p2;
if (a->time < b->time) return -1; if (a->time > b->time) return 1; else return 0;}#else/* not function graph compares against hits */static int function_stat_cmp(const void *p1, const void *p2){ const struct ftrace_profile *a = p1; const struct ftrace_profile *b = p2;
if (a->counter < b->counter) return -1; if (a->counter > b->counter) return 1; else return 0;}#endif
static int function_stat_headers(struct seq_file *m){#ifdef CONFIG_FUNCTION_GRAPH_TRACER seq_puts(m, " Function " "Hit Time Avg s^2\n" " -------- " "--- ---- --- ---\n");#else seq_puts(m, " Function Hit\n" " -------- ---\n");#endif return 0;}
static int function_stat_show(struct seq_file *m, void *v){ struct trace_array *tr = trace_get_global_array(); struct ftrace_profile *rec = v; const char *refsymbol = NULL; char str[KSYM_SYMBOL_LEN];#ifdef CONFIG_FUNCTION_GRAPH_TRACER static struct trace_seq s; unsigned long long avg; unsigned long long stddev; unsigned long long stddev_denom;#endif guard(mutex)(&ftrace_profile_lock);
/* we raced with function_profile_reset() */ if (unlikely(rec->counter == 0)) return -EBUSY;
#ifdef CONFIG_FUNCTION_GRAPH_TRACER avg = div64_ul(rec->time, rec->counter); if (tracing_thresh && (avg < tracing_thresh)) return 0;#endif
if (tr->trace_flags & TRACE_ITER(PROF_TEXT_OFFSET)) { unsigned long offset;
if (core_kernel_text(rec->ip)) { refsymbol = "_text"; offset = rec->ip - (unsigned long)_text; } else { struct module *mod;
guard(rcu)(); mod = __module_text_address(rec->ip); if (mod) { refsymbol = mod->name; /* Calculate offset from module's text entry address. */ offset = rec->ip - (unsigned long)mod->mem[MOD_TEXT].base; } } if (refsymbol) snprintf(str, sizeof(str), " %s+%#lx", refsymbol, offset); } if (!refsymbol) kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
seq_printf(m, " %-30.30s %10lu", str, rec->counter);
#ifdef CONFIG_FUNCTION_GRAPH_TRACER seq_puts(m, " ");
/* * Variance formula: * s^2 = 1 / (n * (n-1)) * (n * \Sum (x_i)^2 - (\Sum x_i)^2) * Maybe Welford's method is better here? * Divide only by 1000 for ns^2 -> us^2 conversion. * trace_print_graph_duration will divide by 1000 again. */ stddev = 0; stddev_denom = rec->counter * (rec->counter - 1) * 1000; if (stddev_denom) { stddev = rec->counter * rec->time_squared - rec->time * rec->time; stddev = div64_ul(stddev, stddev_denom); }
trace_seq_init(&s); trace_print_graph_duration(rec->time, &s); trace_seq_puts(&s, " "); trace_print_graph_duration(avg, &s); trace_seq_puts(&s, " "); trace_print_graph_duration(stddev, &s); trace_print_seq(m, &s);#endif seq_putc(m, '\n');
return 0;}
static void ftrace_profile_reset(struct ftrace_profile_stat *stat){ struct ftrace_profile_page *pg;
pg = stat->pages = stat->start;
while (pg) { memset(pg->records, 0, PROFILE_RECORDS_SIZE); pg->index = 0; pg = pg->next; }
memset(stat->hash, 0, FTRACE_PROFILE_HASH_SIZE * sizeof(struct hlist_head));}
static int ftrace_profile_pages_init(struct ftrace_profile_stat *stat){ struct ftrace_profile_page *pg; int functions; int pages; int i;
/* If we already allocated, do nothing */ if (stat->pages) return 0;
stat->pages = (void *)get_zeroed_page(GFP_KERNEL); if (!stat->pages) return -ENOMEM;
#ifdef CONFIG_DYNAMIC_FTRACE functions = ftrace_update_tot_cnt;#else /* * We do not know the number of functions that exist because * dynamic tracing is what counts them. With past experience * we have around 20K functions. That should be more than enough. * It is highly unlikely we will execute every function in * the kernel. */ functions = 20000;#endif
pg = stat->start = stat->pages;
pages = DIV_ROUND_UP(functions, PROFILES_PER_PAGE);
for (i = 1; i < pages; i++) { pg->next = (void *)get_zeroed_page(GFP_KERNEL); if (!pg->next) goto out_free; pg = pg->next; }
return 0;
out_free: pg = stat->start; while (pg) { unsigned long tmp = (unsigned long)pg;
pg = pg->next; free_page(tmp); }
stat->pages = NULL; stat->start = NULL;
return -ENOMEM;}
static int ftrace_profile_init_cpu(int cpu){ struct ftrace_profile_stat *stat; int size;
stat = &per_cpu(ftrace_profile_stats, cpu);
if (stat->hash) { /* If the profile is already created, simply reset it */ ftrace_profile_reset(stat); return 0; }
/* * We are profiling all functions, but usually only a few thousand * functions are hit. We'll make a hash of 1024 items. */ size = FTRACE_PROFILE_HASH_SIZE;
stat->hash = kzalloc_objs(struct hlist_head, size);
if (!stat->hash) return -ENOMEM;
/* Preallocate the function profiling pages */ if (ftrace_profile_pages_init(stat) < 0) { kfree(stat->hash); stat->hash = NULL; return -ENOMEM; }
return 0;}
static int ftrace_profile_init(void){ int cpu; int ret = 0;
for_each_possible_cpu(cpu) { ret = ftrace_profile_init_cpu(cpu); if (ret) break; }
return ret;}
/* interrupts must be disabled */static struct ftrace_profile *ftrace_find_profiled_func(struct ftrace_profile_stat *stat, unsigned long ip){ struct ftrace_profile *rec; struct hlist_head *hhd; unsigned long key;
key = hash_long(ip, FTRACE_PROFILE_HASH_BITS); hhd = &stat->hash[key];
if (hlist_empty(hhd)) return NULL;
hlist_for_each_entry_rcu_notrace(rec, hhd, node) { if (rec->ip == ip) return rec; }
return NULL;}
static void ftrace_add_profile(struct ftrace_profile_stat *stat, struct ftrace_profile *rec){ unsigned long key;
key = hash_long(rec->ip, FTRACE_PROFILE_HASH_BITS); hlist_add_head_rcu(&rec->node, &stat->hash[key]);}
/* * The memory is already allocated, this simply finds a new record to use. */static struct ftrace_profile *ftrace_profile_alloc(struct ftrace_profile_stat *stat, unsigned long ip){ struct ftrace_profile *rec = NULL;
/* prevent recursion (from NMIs) */ if (atomic_inc_return(&stat->disabled) != 1) goto out;
/* * Try to find the function again since an NMI * could have added it */ rec = ftrace_find_profiled_func(stat, ip); if (rec) goto out;
if (stat->pages->index == PROFILES_PER_PAGE) { if (!stat->pages->next) goto out; stat->pages = stat->pages->next; }
rec = &stat->pages->records[stat->pages->index++]; rec->ip = ip; ftrace_add_profile(stat, rec);
out: atomic_dec(&stat->disabled);
return rec;}
static voidfunction_profile_call(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *ops, struct ftrace_regs *fregs){ struct ftrace_profile_stat *stat; struct ftrace_profile *rec;
if (!ftrace_profile_enabled) return;
guard(preempt_notrace)();
stat = this_cpu_ptr(&ftrace_profile_stats); if (!stat->hash || !ftrace_profile_enabled) return;
rec = ftrace_find_profiled_func(stat, ip); if (!rec) { rec = ftrace_profile_alloc(stat, ip); if (!rec) return; }
rec->counter++;}
#ifdef CONFIG_FUNCTION_GRAPH_TRACERstatic bool fgraph_graph_time = true;
void ftrace_graph_graph_time_control(bool enable){ fgraph_graph_time = enable;}
struct profile_fgraph_data { unsigned long long calltime; unsigned long long subtime; unsigned long long sleeptime;};
static int profile_graph_entry(struct ftrace_graph_ent *trace, struct fgraph_ops *gops, struct ftrace_regs *fregs){ struct profile_fgraph_data *profile_data;
function_profile_call(trace->func, 0, NULL, NULL);
/* If function graph is shutting down, ret_stack can be NULL */ if (!current->ret_stack) return 0;
profile_data = fgraph_reserve_data(gops->idx, sizeof(*profile_data)); if (!profile_data) return 0;
profile_data->subtime = 0; profile_data->sleeptime = current->ftrace_sleeptime; profile_data->calltime = trace_clock_local();
return 1;}
bool fprofile_no_sleep_time;
static void profile_graph_return(struct ftrace_graph_ret *trace, struct fgraph_ops *gops, struct ftrace_regs *fregs){ struct profile_fgraph_data *profile_data; struct ftrace_profile_stat *stat; unsigned long long calltime; unsigned long long rettime = trace_clock_local(); struct ftrace_profile *rec; int size;
guard(preempt_notrace)();
stat = this_cpu_ptr(&ftrace_profile_stats); if (!stat->hash || !ftrace_profile_enabled) return;
profile_data = fgraph_retrieve_data(gops->idx, &size);
/* If the calltime was zero'd ignore it */ if (!profile_data || !profile_data->calltime) return;
calltime = rettime - profile_data->calltime;
if (fprofile_no_sleep_time) { if (current->ftrace_sleeptime) calltime -= current->ftrace_sleeptime - profile_data->sleeptime; }
if (!fgraph_graph_time) { struct profile_fgraph_data *parent_data;
/* Append this call time to the parent time to subtract */ parent_data = fgraph_retrieve_parent_data(gops->idx, &size, 1); if (parent_data) parent_data->subtime += calltime;
if (profile_data->subtime && profile_data->subtime < calltime) calltime -= profile_data->subtime; else calltime = 0; }
rec = ftrace_find_profiled_func(stat, trace->func); if (rec) { rec->time += calltime; rec->time_squared += calltime * calltime; }}
static struct fgraph_ops fprofiler_ops = { .entryfunc = &profile_graph_entry, .retfunc = &profile_graph_return,};
static int register_ftrace_profiler(void){ ftrace_ops_set_global_filter(&fprofiler_ops.ops); return register_ftrace_graph(&fprofiler_ops);}
static void unregister_ftrace_profiler(void){ unregister_ftrace_graph(&fprofiler_ops);}#elsestatic struct ftrace_ops ftrace_profile_ops __read_mostly = { .func = function_profile_call,};
static int register_ftrace_profiler(void){ ftrace_ops_set_global_filter(&ftrace_profile_ops); return register_ftrace_function(&ftrace_profile_ops);}
static void unregister_ftrace_profiler(void){ unregister_ftrace_function(&ftrace_profile_ops);}#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
static ssize_tftrace_profile_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *ppos){ unsigned long val; int ret;
ret = kstrtoul_from_user(ubuf, cnt, 10, &val); if (ret) return ret;
val = !!val;
guard(mutex)(&ftrace_profile_lock); if (ftrace_profile_enabled ^ val) { if (val) { ret = ftrace_profile_init(); if (ret < 0) return ret;
ret = register_ftrace_profiler(); if (ret < 0) return ret; ftrace_profile_enabled = 1; } else { ftrace_profile_enabled = 0; /* * unregister_ftrace_profiler calls stop_machine * so this acts like an synchronize_rcu. */ unregister_ftrace_profiler(); } }
*ppos += cnt;
return cnt;}
static ssize_tftrace_profile_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos){ char buf[64]; /* big enough to hold a number */ int r;
r = sprintf(buf, "%u\n", ftrace_profile_enabled); return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);}
static const struct file_operations ftrace_profile_fops = { .open = tracing_open_generic, .read = ftrace_profile_read, .write = ftrace_profile_write, .llseek = default_llseek,};
/* used to initialize the real stat files */static struct tracer_stat function_stats __initdata = { .name = "functions", .stat_start = function_stat_start, .stat_next = function_stat_next, .stat_cmp = function_stat_cmp, .stat_headers = function_stat_headers, .stat_show = function_stat_show};
static __init void ftrace_profile_tracefs(struct dentry *d_tracer){ struct ftrace_profile_stat *stat; char *name; int ret; int cpu;
for_each_possible_cpu(cpu) { stat = &per_cpu(ftrace_profile_stats, cpu);
name = kasprintf(GFP_KERNEL, "function%d", cpu); if (!name) { /* * The files created are permanent, if something happens * we still do not free memory. */ WARN(1, "Could not allocate stat file for cpu %d\n", cpu); return; } stat->stat = function_stats; stat->stat.name = name; ret = register_stat_tracer(&stat->stat); if (ret) { WARN(1, "Could not register function stat for cpu %d\n", cpu); kfree(name); return; } }
trace_create_file("function_profile_enabled", TRACE_MODE_WRITE, d_tracer, NULL, &ftrace_profile_fops);}
#else /* CONFIG_FUNCTION_PROFILER */static __init void ftrace_profile_tracefs(struct dentry *d_tracer){}#endif /* CONFIG_FUNCTION_PROFILER */
#ifdef CONFIG_DYNAMIC_FTRACE
static struct ftrace_ops *removed_ops;
/* * Set when doing a global update, like enabling all recs or disabling them. * It is not set when just updating a single ftrace_ops. */static bool update_all_ops;
struct ftrace_func_probe { struct ftrace_probe_ops *probe_ops; struct ftrace_ops ops; struct trace_array *tr; struct list_head list; void *data; int ref;};
/* * We make these constant because no one should touch them, * but they are used as the default "empty hash", to avoid allocating * it all the time. These are in a read only section such that if * anyone does try to modify it, it will cause an exception. */static const struct hlist_head empty_buckets[1];static const struct ftrace_hash empty_hash = { .buckets = (struct hlist_head *)empty_buckets,};#define EMPTY_HASH ((struct ftrace_hash *)&empty_hash)
struct ftrace_ops global_ops = { .func = ftrace_stub, .local_hash.notrace_hash = EMPTY_HASH, .local_hash.filter_hash = EMPTY_HASH, INIT_OPS_HASH(global_ops) .flags = FTRACE_OPS_FL_INITIALIZED | FTRACE_OPS_FL_PID,};
/* * parser_lock - Protects trace_parser state against concurrent operations. * Held across trace_get_user() and subsequent buffer parsing to prevent races. */static DEFINE_MUTEX(parser_lock);
/* * Used by the stack unwinder to know about dynamic ftrace trampolines. */struct ftrace_ops *ftrace_ops_trampoline(unsigned long addr){ struct ftrace_ops *op = NULL;
/* * Some of the ops may be dynamically allocated, * they are freed after a synchronize_rcu(). */ preempt_disable_notrace();
do_for_each_ftrace_op(op, ftrace_ops_list) { /* * This is to check for dynamically allocated trampolines. * Trampolines that are in kernel text will have * core_kernel_text() return true. */ if (op->trampoline && op->trampoline_size) if (addr >= op->trampoline && addr < op->trampoline + op->trampoline_size) { preempt_enable_notrace(); return op; } } while_for_each_ftrace_op(op); preempt_enable_notrace();
return NULL;}
/* * This is used by __kernel_text_address() to return true if the * address is on a dynamically allocated trampoline that would * not return true for either core_kernel_text() or * is_module_text_address(). */bool is_ftrace_trampoline(unsigned long addr){ return ftrace_ops_trampoline(addr) != NULL;}
struct ftrace_page { struct ftrace_page *next; struct dyn_ftrace *records; int index; int order;};
#define ENTRY_SIZE sizeof(struct dyn_ftrace)#define ENTRIES_PER_PAGE_GROUP(order) ((PAGE_SIZE << (order)) / ENTRY_SIZE)
static struct ftrace_page *ftrace_pages_start;static struct ftrace_page *ftrace_pages;
static __always_inline unsigned longftrace_hash_key(struct ftrace_hash *hash, unsigned long ip){ if (hash->size_bits > 0) return hash_long(ip, hash->size_bits);
return 0;}
/* Only use this function if ftrace_hash_empty() has already been tested */static __always_inline struct ftrace_func_entry *__ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip){ unsigned long key; struct ftrace_func_entry *entry; struct hlist_head *hhd;
key = ftrace_hash_key(hash, ip); hhd = &hash->buckets[key];
hlist_for_each_entry_rcu_notrace(entry, hhd, hlist) { if (entry->ip == ip) return entry; } return NULL;}
/** * ftrace_lookup_ip - Test to see if an ip exists in an ftrace_hash * @hash: The hash to look at * @ip: The instruction pointer to test * * Search a given @hash to see if a given instruction pointer (@ip) * exists in it. * * Returns: the entry that holds the @ip if found. NULL otherwise. */struct ftrace_func_entry *ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip){ if (ftrace_hash_empty(hash)) return NULL;
return __ftrace_lookup_ip(hash, ip);}
void add_ftrace_hash_entry(struct ftrace_hash *hash, struct ftrace_func_entry *entry){ struct hlist_head *hhd; unsigned long key;
key = ftrace_hash_key(hash, entry->ip); hhd = &hash->buckets[key]; hlist_add_head(&entry->hlist, hhd); hash->count++;}
struct ftrace_func_entry *add_ftrace_hash_entry_direct(struct ftrace_hash *hash, unsigned long ip, unsigned long direct){ struct ftrace_func_entry *entry;
entry = kmalloc_obj(*entry); if (!entry) return NULL;
entry->ip = ip; entry->direct = direct; add_ftrace_hash_entry(hash, entry);
return entry;}
static struct ftrace_func_entry *add_hash_entry(struct ftrace_hash *hash, unsigned long ip){ return add_ftrace_hash_entry_direct(hash, ip, 0);}
static voidfree_hash_entry(struct ftrace_hash *hash, struct ftrace_func_entry *entry){ hlist_del(&entry->hlist); kfree(entry); hash->count--;}
static voidremove_hash_entry(struct ftrace_hash *hash, struct ftrace_func_entry *entry){ hlist_del_rcu(&entry->hlist); hash->count--;}
void ftrace_hash_remove(struct ftrace_hash *hash){ struct ftrace_func_entry *entry; struct hlist_head *hhd; struct hlist_node *tn; int size; int i;
if (!hash || !hash->count) return; size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hhd = &hash->buckets[i]; hlist_for_each_entry_safe(entry, tn, hhd, hlist) remove_hash_entry(hash, entry); } FTRACE_WARN_ON(hash->count);}
static void ftrace_hash_clear(struct ftrace_hash *hash){ struct hlist_head *hhd; struct hlist_node *tn; struct ftrace_func_entry *entry; int size = 1 << hash->size_bits; int i;
if (!hash->count) return;
for (i = 0; i < size; i++) { hhd = &hash->buckets[i]; hlist_for_each_entry_safe(entry, tn, hhd, hlist) free_hash_entry(hash, entry); } FTRACE_WARN_ON(hash->count);}
static void free_ftrace_mod(struct ftrace_mod_load *ftrace_mod){ list_del(&ftrace_mod->list); kfree(ftrace_mod->module); kfree(ftrace_mod->func); kfree(ftrace_mod);}
static void clear_ftrace_mod_list(struct list_head *head){ struct ftrace_mod_load *p, *n;
/* stack tracer isn't supported yet */ if (!head) return;
mutex_lock(&ftrace_lock); list_for_each_entry_safe(p, n, head, list) free_ftrace_mod(p); mutex_unlock(&ftrace_lock);}
void free_ftrace_hash(struct ftrace_hash *hash){ if (!hash || hash == EMPTY_HASH) return; ftrace_hash_clear(hash); kfree(hash->buckets); kfree(hash);}
static void __free_ftrace_hash_rcu(struct rcu_head *rcu){ struct ftrace_hash *hash;
hash = container_of(rcu, struct ftrace_hash, rcu); free_ftrace_hash(hash);}
static void free_ftrace_hash_rcu(struct ftrace_hash *hash){ if (!hash || hash == EMPTY_HASH) return; call_rcu(&hash->rcu, __free_ftrace_hash_rcu);}
/** * ftrace_free_filter - remove all filters for an ftrace_ops * @ops: the ops to remove the filters from */void ftrace_free_filter(struct ftrace_ops *ops){ ftrace_ops_init(ops); if (WARN_ON(ops->flags & FTRACE_OPS_FL_ENABLED)) return; free_ftrace_hash(ops->func_hash->filter_hash); free_ftrace_hash(ops->func_hash->notrace_hash); ops->func_hash->filter_hash = EMPTY_HASH; ops->func_hash->notrace_hash = EMPTY_HASH;}EXPORT_SYMBOL_GPL(ftrace_free_filter);
struct ftrace_hash *alloc_ftrace_hash(int size_bits){ struct ftrace_hash *hash; int size;
hash = kzalloc_obj(*hash); if (!hash) return NULL;
size = 1 << size_bits; hash->buckets = kzalloc_objs(*hash->buckets, size);
if (!hash->buckets) { kfree(hash); return NULL; }
hash->size_bits = size_bits;
return hash;}
/* Used to save filters on functions for modules not loaded yet */static int ftrace_add_mod(struct trace_array *tr, const char *func, const char *module, int enable){ struct ftrace_mod_load *ftrace_mod; struct list_head *mod_head = enable ? &tr->mod_trace : &tr->mod_notrace;
ftrace_mod = kzalloc_obj(*ftrace_mod); if (!ftrace_mod) return -ENOMEM;
INIT_LIST_HEAD(&ftrace_mod->list); ftrace_mod->func = kstrdup(func, GFP_KERNEL); ftrace_mod->module = kstrdup(module, GFP_KERNEL); ftrace_mod->enable = enable;
if (!ftrace_mod->func || !ftrace_mod->module) goto out_free;
list_add(&ftrace_mod->list, mod_head);
return 0;
out_free: free_ftrace_mod(ftrace_mod);
return -ENOMEM;}
static struct ftrace_hash *alloc_and_copy_ftrace_hash(int size_bits, struct ftrace_hash *hash){ struct ftrace_func_entry *entry; struct ftrace_hash *new_hash; int size; int i;
new_hash = alloc_ftrace_hash(size_bits); if (!new_hash) return NULL;
if (hash) new_hash->flags = hash->flags;
/* Empty hash? */ if (ftrace_hash_empty(hash)) return new_hash;
size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &hash->buckets[i], hlist) { if (add_ftrace_hash_entry_direct(new_hash, entry->ip, entry->direct) == NULL) goto free_hash; } }
FTRACE_WARN_ON(new_hash->count != hash->count);
return new_hash;
free_hash: free_ftrace_hash(new_hash); return NULL;}
static void ftrace_hash_rec_disable_modify(struct ftrace_ops *ops);static void ftrace_hash_rec_enable_modify(struct ftrace_ops *ops);
static int ftrace_hash_ipmodify_update(struct ftrace_ops *ops, struct ftrace_hash *new_hash);
/* * Allocate a new hash and remove entries from @src and move them to the new hash. * On success, the @src hash will be empty and should be freed. */static struct ftrace_hash *__move_hash(struct ftrace_hash *src, int size){ struct ftrace_func_entry *entry; struct ftrace_hash *new_hash; struct hlist_head *hhd; struct hlist_node *tn; int bits = 0; int i;
/* * Use around half the size (max bit of it), but * a minimum of 2 is fine (as size of 0 or 1 both give 1 for bits). */ bits = fls(size / 2);
/* Don't allocate too much */ if (bits > FTRACE_HASH_MAX_BITS) bits = FTRACE_HASH_MAX_BITS;
new_hash = alloc_ftrace_hash(bits); if (!new_hash) return NULL;
new_hash->flags = src->flags;
size = 1 << src->size_bits; for (i = 0; i < size; i++) { hhd = &src->buckets[i]; hlist_for_each_entry_safe(entry, tn, hhd, hlist) { remove_hash_entry(src, entry); add_ftrace_hash_entry(new_hash, entry); } } return new_hash;}
/* Move the @src entries to a newly allocated hash */static struct ftrace_hash *__ftrace_hash_move(struct ftrace_hash *src){ int size = src->count;
/* * If the new source is empty, just return the empty_hash. */ if (ftrace_hash_empty(src)) return EMPTY_HASH;
return __move_hash(src, size);}
/** * ftrace_hash_move - move a new hash to a filter and do updates * @ops: The ops with the hash that @dst points to * @enable: True if for the filter hash, false for the notrace hash * @dst: Points to the @ops hash that should be updated * @src: The hash to update @dst with * * This is called when an ftrace_ops hash is being updated and the * the kernel needs to reflect this. Note, this only updates the kernel * function callbacks if the @ops is enabled (not to be confused with * @enable above). If the @ops is enabled, its hash determines what * callbacks get called. This function gets called when the @ops hash * is updated and it requires new callbacks. * * On success the elements of @src is moved to @dst, and @dst is updated * properly, as well as the functions determined by the @ops hashes * are now calling the @ops callback function. * * Regardless of return type, @src should be freed with free_ftrace_hash(). */static intftrace_hash_move(struct ftrace_ops *ops, int enable, struct ftrace_hash **dst, struct ftrace_hash *src){ struct ftrace_hash *new_hash; int ret;
/* Reject setting notrace hash on IPMODIFY ftrace_ops */ if (ops->flags & FTRACE_OPS_FL_IPMODIFY && !enable) return -EINVAL;
new_hash = __ftrace_hash_move(src); if (!new_hash) return -ENOMEM;
/* Make sure this can be applied if it is IPMODIFY ftrace_ops */ if (enable) { /* IPMODIFY should be updated only when filter_hash updating */ ret = ftrace_hash_ipmodify_update(ops, new_hash); if (ret < 0) { free_ftrace_hash(new_hash); return ret; } }
/* * Remove the current set, update the hash and add * them back. */ ftrace_hash_rec_disable_modify(ops);
rcu_assign_pointer(*dst, new_hash);
ftrace_hash_rec_enable_modify(ops);
return 0;}
static bool hash_contains_ip(unsigned long ip, struct ftrace_ops_hash *hash){ /* * The function record is a match if it exists in the filter * hash and not in the notrace hash. Note, an empty hash is * considered a match for the filter hash, but an empty * notrace hash is considered not in the notrace hash. */ return (ftrace_hash_empty(hash->filter_hash) || __ftrace_lookup_ip(hash->filter_hash, ip)) && (ftrace_hash_empty(hash->notrace_hash) || !__ftrace_lookup_ip(hash->notrace_hash, ip));}
/* * Test the hashes for this ops to see if we want to call * the ops->func or not. * * It's a match if the ip is in the ops->filter_hash or * the filter_hash does not exist or is empty, * AND * the ip is not in the ops->notrace_hash. * * This needs to be called with preemption disabled as * the hashes are freed with call_rcu(). */intftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs){ struct ftrace_ops_hash hash; int ret;
#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS /* * There's a small race when adding ops that the ftrace handler * that wants regs, may be called without them. We can not * allow that handler to be called if regs is NULL. */ if (regs == NULL && (ops->flags & FTRACE_OPS_FL_SAVE_REGS)) return 0;#endif
rcu_assign_pointer(hash.filter_hash, ops->func_hash->filter_hash); rcu_assign_pointer(hash.notrace_hash, ops->func_hash->notrace_hash);
if (hash_contains_ip(ip, &hash)) ret = 1; else ret = 0;
return ret;}
/* * This is a double for. Do not use 'break' to break out of the loop, * you must use a goto. */#define do_for_each_ftrace_rec(pg, rec) \ for (pg = ftrace_pages_start; pg; pg = pg->next) { \ int _____i; \ for (_____i = 0; _____i < pg->index; _____i++) { \ rec = &pg->records[_____i];
#define while_for_each_ftrace_rec() \ } \ }
static int ftrace_cmp_recs(const void *a, const void *b){ const struct dyn_ftrace *key = a; const struct dyn_ftrace *rec = b;
if (key->flags < rec->ip) return -1; if (key->ip >= rec->ip + MCOUNT_INSN_SIZE) return 1; return 0;}
static struct dyn_ftrace *lookup_rec(unsigned long start, unsigned long end){ struct ftrace_page *pg; struct dyn_ftrace *rec = NULL; struct dyn_ftrace key;
key.ip = start; key.flags = end; /* overload flags, as it is unsigned long */
for (pg = ftrace_pages_start; pg; pg = pg->next) { if (pg->index == 0 || end < pg->records[0].ip || start >= (pg->records[pg->index - 1].ip + MCOUNT_INSN_SIZE)) continue; rec = bsearch(&key, pg->records, pg->index, sizeof(struct dyn_ftrace), ftrace_cmp_recs); if (rec) break; } return rec;}
/** * ftrace_location_range - return the first address of a traced location * if it touches the given ip range * @start: start of range to search. * @end: end of range to search (inclusive). @end points to the last byte * to check. * * Returns: rec->ip if the related ftrace location is a least partly within * the given address range. That is, the first address of the instruction * that is either a NOP or call to the function tracer. It checks the ftrace * internal tables to determine if the address belongs or not. */unsigned long ftrace_location_range(unsigned long start, unsigned long end){ struct dyn_ftrace *rec; unsigned long ip = 0;
rcu_read_lock(); rec = lookup_rec(start, end); if (rec) ip = rec->ip; rcu_read_unlock();
return ip;}
/** * ftrace_location - return the ftrace location * @ip: the instruction pointer to check * * Returns: * * If @ip matches the ftrace location, return @ip. * * If @ip matches sym+0, return sym's ftrace location. * * Otherwise, return 0. */unsigned long ftrace_location(unsigned long ip){ unsigned long loc; unsigned long offset; unsigned long size;
loc = ftrace_location_range(ip, ip); if (!loc) { if (!kallsyms_lookup_size_offset(ip, &size, &offset)) return 0;
/* map sym+0 to __fentry__ */ if (!offset) loc = ftrace_location_range(ip, ip + size - 1); } return loc;}
/** * ftrace_text_reserved - return true if range contains an ftrace location * @start: start of range to search * @end: end of range to search (inclusive). @end points to the last byte to check. * * Returns: 1 if @start and @end contains a ftrace location. * That is, the instruction that is either a NOP or call to * the function tracer. It checks the ftrace internal tables to * determine if the address belongs or not. */int ftrace_text_reserved(const void *start, const void *end){ unsigned long ret;
ret = ftrace_location_range((unsigned long)start, (unsigned long)end);
return (int)!!ret;}
/* Test if ops registered to this rec needs regs */static bool test_rec_ops_needs_regs(struct dyn_ftrace *rec){ struct ftrace_ops *ops; bool keep_regs = false;
for (ops = ftrace_ops_list; ops != &ftrace_list_end; ops = ops->next) { /* pass rec in as regs to have non-NULL val */ if (ftrace_ops_test(ops, rec->ip, rec)) { if (ops->flags & FTRACE_OPS_FL_SAVE_REGS) { keep_regs = true; break; } } }
return keep_regs;}
static struct ftrace_ops *ftrace_find_tramp_ops_any(struct dyn_ftrace *rec);static struct ftrace_ops *ftrace_find_tramp_ops_any_other(struct dyn_ftrace *rec, struct ftrace_ops *op_exclude);static struct ftrace_ops *ftrace_find_tramp_ops_next(struct dyn_ftrace *rec, struct ftrace_ops *ops);
static bool skip_record(struct dyn_ftrace *rec){ /* * At boot up, weak functions are set to disable. Function tracing * can be enabled before they are, and they still need to be disabled now. * If the record is disabled, still continue if it is marked as already * enabled (this is needed to keep the accounting working). */ return rec->flags & FTRACE_FL_DISABLED && !(rec->flags & FTRACE_FL_ENABLED);}
/* * This is the main engine to the ftrace updates to the dyn_ftrace records. * * It will iterate through all the available ftrace functions * (the ones that ftrace can have callbacks to) and set the flags * in the associated dyn_ftrace records. * * @inc: If true, the functions associated to @ops are added to * the dyn_ftrace records, otherwise they are removed. */static bool __ftrace_hash_rec_update(struct ftrace_ops *ops, bool inc){ struct ftrace_hash *hash; struct ftrace_hash *notrace_hash; struct ftrace_page *pg; struct dyn_ftrace *rec; bool update = false; int count = 0; int all = false;
/* Only update if the ops has been registered */ if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) return false;
/* * If the count is zero, we update all records. * Otherwise we just update the items in the hash. */ hash = ops->func_hash->filter_hash; notrace_hash = ops->func_hash->notrace_hash; if (ftrace_hash_empty(hash)) all = true;
do_for_each_ftrace_rec(pg, rec) { int in_notrace_hash = 0; int in_hash = 0; int match = 0;
if (skip_record(rec)) continue;
if (all) { /* * Only the filter_hash affects all records. * Update if the record is not in the notrace hash. */ if (!notrace_hash || !ftrace_lookup_ip(notrace_hash, rec->ip)) match = 1; } else { in_hash = !!ftrace_lookup_ip(hash, rec->ip); in_notrace_hash = !!ftrace_lookup_ip(notrace_hash, rec->ip);
/* * We want to match all functions that are in the hash but * not in the other hash. */ if (in_hash && !in_notrace_hash) match = 1; } if (!match) continue;
if (inc) { rec->flags++; if (FTRACE_WARN_ON(ftrace_rec_count(rec) == FTRACE_REF_MAX)) return false;
if (ops->flags & FTRACE_OPS_FL_DIRECT) rec->flags |= FTRACE_FL_DIRECT;
/* * If there's only a single callback registered to a * function, and the ops has a trampoline registered * for it, then we can call it directly. */ if (ftrace_rec_count(rec) == 1 && ops->trampoline) rec->flags |= FTRACE_FL_TRAMP; else /* * If we are adding another function callback * to this function, and the previous had a * custom trampoline in use, then we need to go * back to the default trampoline. */ rec->flags &= ~FTRACE_FL_TRAMP;
/* * If any ops wants regs saved for this function * then all ops will get saved regs. */ if (ops->flags & FTRACE_OPS_FL_SAVE_REGS) rec->flags |= FTRACE_FL_REGS; } else { if (FTRACE_WARN_ON(ftrace_rec_count(rec) == 0)) return false; rec->flags--;
/* * Only the internal direct_ops should have the * DIRECT flag set. Thus, if it is removing a * function, then that function should no longer * be direct. */ if (ops->flags & FTRACE_OPS_FL_DIRECT) rec->flags &= ~FTRACE_FL_DIRECT;
/* * If the rec had REGS enabled and the ops that is * being removed had REGS set, then see if there is * still any ops for this record that wants regs. * If not, we can stop recording them. */ if (ftrace_rec_count(rec) > 0 && rec->flags & FTRACE_FL_REGS && ops->flags & FTRACE_OPS_FL_SAVE_REGS) { if (!test_rec_ops_needs_regs(rec)) rec->flags &= ~FTRACE_FL_REGS; }
/* * The TRAMP needs to be set only if rec count * is decremented to one, and the ops that is * left has a trampoline. As TRAMP can only be * enabled if there is only a single ops attached * to it. */ if (ftrace_rec_count(rec) == 1 && ftrace_find_tramp_ops_any_other(rec, ops)) rec->flags |= FTRACE_FL_TRAMP; else rec->flags &= ~FTRACE_FL_TRAMP;
/* * flags will be cleared in ftrace_check_record() * if rec count is zero. */ }
/* * If the rec has a single associated ops, and ops->func can be * called directly, allow the call site to call via the ops. */ if (IS_ENABLED(CONFIG_DYNAMIC_FTRACE_WITH_CALL_OPS) && ftrace_rec_count(rec) == 1 && ftrace_ops_get_func(ops) == ops->func) rec->flags |= FTRACE_FL_CALL_OPS; else rec->flags &= ~FTRACE_FL_CALL_OPS;
count++;
/* Must match FTRACE_UPDATE_CALLS in ftrace_modify_all_code() */ update |= ftrace_test_record(rec, true) != FTRACE_UPDATE_IGNORE;
/* Shortcut, if we handled all records, we are done. */ if (!all && count == hash->count) return update; } while_for_each_ftrace_rec();
return update;}
/* * This is called when an ops is removed from tracing. It will decrement * the counters of the dyn_ftrace records for all the functions that * the @ops attached to. */static bool ftrace_hash_rec_disable(struct ftrace_ops *ops){ return __ftrace_hash_rec_update(ops, false);}
/* * This is called when an ops is added to tracing. It will increment * the counters of the dyn_ftrace records for all the functions that * the @ops attached to. */static bool ftrace_hash_rec_enable(struct ftrace_ops *ops){ return __ftrace_hash_rec_update(ops, true);}
/* * This function will update what functions @ops traces when its filter * changes. * * The @inc states if the @ops callbacks are going to be added or removed. * When one of the @ops hashes are updated to a "new_hash" the dyn_ftrace * records are update via: * * ftrace_hash_rec_disable_modify(ops); * ops->hash = new_hash * ftrace_hash_rec_enable_modify(ops); * * Where the @ops is removed from all the records it is tracing using * its old hash. The @ops hash is updated to the new hash, and then * the @ops is added back to the records so that it is tracing all * the new functions. */static void ftrace_hash_rec_update_modify(struct ftrace_ops *ops, bool inc){ struct ftrace_ops *op;
__ftrace_hash_rec_update(ops, inc);
if (ops->func_hash != &global_ops.local_hash) return;
/* * If the ops shares the global_ops hash, then we need to update * all ops that are enabled and use this hash. */ do_for_each_ftrace_op(op, ftrace_ops_list) { /* Already done */ if (op == ops) continue; if (op->func_hash == &global_ops.local_hash) __ftrace_hash_rec_update(op, inc); } while_for_each_ftrace_op(op);}
static void ftrace_hash_rec_disable_modify(struct ftrace_ops *ops){ ftrace_hash_rec_update_modify(ops, false);}
static void ftrace_hash_rec_enable_modify(struct ftrace_ops *ops){ ftrace_hash_rec_update_modify(ops, true);}
/* * Try to update IPMODIFY flag on each ftrace_rec. Return 0 if it is OK * or no-needed to update, -EBUSY if it detects a conflict of the flag * on a ftrace_rec, and -EINVAL if the new_hash tries to trace all recs. * Note that old_hash and new_hash has below meanings * - If the hash is NULL, it hits all recs (if IPMODIFY is set, this is rejected) * - If the hash is EMPTY_HASH, it hits nothing * - Anything else hits the recs which match the hash entries. * * DIRECT ops does not have IPMODIFY flag, but we still need to check it * against functions with FTRACE_FL_IPMODIFY. If there is any overlap, call * ops_func(SHARE_IPMODIFY_SELF) to make sure current ops can share with * IPMODIFY. If ops_func(SHARE_IPMODIFY_SELF) returns non-zero, propagate * the return value to the caller and eventually to the owner of the DIRECT * ops. */static int __ftrace_hash_update_ipmodify(struct ftrace_ops *ops, struct ftrace_hash *old_hash, struct ftrace_hash *new_hash, bool update_target){ struct ftrace_page *pg; struct dyn_ftrace *rec, *end = NULL; int in_old, in_new; bool is_ipmodify, is_direct;
/* Only update if the ops has been registered */ if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) return 0;
is_ipmodify = ops->flags & FTRACE_OPS_FL_IPMODIFY; is_direct = ops->flags & FTRACE_OPS_FL_DIRECT;
/* neither IPMODIFY nor DIRECT, skip */ if (!is_ipmodify && !is_direct) return 0;
if (WARN_ON_ONCE(is_ipmodify && is_direct)) return 0;
/* * Since the IPMODIFY and DIRECT are very address sensitive * actions, we do not allow ftrace_ops to set all functions to new * hash. */ if (!new_hash || !old_hash) return -EINVAL;
/* Update rec->flags */ do_for_each_ftrace_rec(pg, rec) {
if (rec->flags & FTRACE_FL_DISABLED) continue;
/* * Unless we are updating the target of a direct function, * we only need to update differences of filter_hash */ in_old = !!ftrace_lookup_ip(old_hash, rec->ip); in_new = !!ftrace_lookup_ip(new_hash, rec->ip); if (!update_target && (in_old == in_new)) continue;
if (in_new) { if (rec->flags & FTRACE_FL_IPMODIFY) { int ret;
/* Cannot have two ipmodify on same rec */ if (is_ipmodify) goto rollback;
/* * If this is called by __modify_ftrace_direct() * then it is only changing where the direct * pointer is jumping to, and the record already * points to a direct trampoline. If it isn't, * then it is a bug to update ipmodify on a direct * caller. */ FTRACE_WARN_ON(!update_target && (rec->flags & FTRACE_FL_DIRECT));
/* * Another ops with IPMODIFY is already * attached. We are now attaching a direct * ops. Run SHARE_IPMODIFY_SELF, to check * whether sharing is supported. */ if (!ops->ops_func) return -EBUSY; ret = ops->ops_func(ops, rec->ip, FTRACE_OPS_CMD_ENABLE_SHARE_IPMODIFY_SELF); if (ret) return ret; } else if (is_ipmodify) { rec->flags |= FTRACE_FL_IPMODIFY; } } else if (is_ipmodify) { rec->flags &= ~FTRACE_FL_IPMODIFY; } } while_for_each_ftrace_rec();
return 0;
rollback: end = rec;
/* Roll back what we did above */ do_for_each_ftrace_rec(pg, rec) {
if (rec->flags & FTRACE_FL_DISABLED) continue;
if (rec == end) return -EBUSY;
in_old = !!ftrace_lookup_ip(old_hash, rec->ip); in_new = !!ftrace_lookup_ip(new_hash, rec->ip); if (in_old == in_new) continue;
if (in_new) rec->flags &= ~FTRACE_FL_IPMODIFY; else rec->flags |= FTRACE_FL_IPMODIFY; } while_for_each_ftrace_rec();
return -EBUSY;}
static int ftrace_hash_ipmodify_enable(struct ftrace_ops *ops){ struct ftrace_hash *hash = ops->func_hash->filter_hash;
if (ftrace_hash_empty(hash)) hash = NULL;
return __ftrace_hash_update_ipmodify(ops, EMPTY_HASH, hash, false);}
/* Disabling always succeeds */static void ftrace_hash_ipmodify_disable(struct ftrace_ops *ops){ struct ftrace_hash *hash = ops->func_hash->filter_hash;
if (ftrace_hash_empty(hash)) hash = NULL;
__ftrace_hash_update_ipmodify(ops, hash, EMPTY_HASH, false);}
static int ftrace_hash_ipmodify_update(struct ftrace_ops *ops, struct ftrace_hash *new_hash){ struct ftrace_hash *old_hash = ops->func_hash->filter_hash;
if (ftrace_hash_empty(old_hash)) old_hash = NULL;
if (ftrace_hash_empty(new_hash)) new_hash = NULL;
return __ftrace_hash_update_ipmodify(ops, old_hash, new_hash, false);}
static void print_ip_ins(const char *fmt, const unsigned char *p){ char ins[MCOUNT_INSN_SIZE];
if (copy_from_kernel_nofault(ins, p, MCOUNT_INSN_SIZE)) { printk(KERN_CONT "%s[FAULT] %px\n", fmt, p); return; }
printk(KERN_CONT "%s", fmt); pr_cont("%*phC", MCOUNT_INSN_SIZE, ins);}
enum ftrace_bug_type ftrace_bug_type;const void *ftrace_expected;
static void print_bug_type(void){ switch (ftrace_bug_type) { case FTRACE_BUG_UNKNOWN: break; case FTRACE_BUG_INIT: pr_info("Initializing ftrace call sites\n"); break; case FTRACE_BUG_NOP: pr_info("Setting ftrace call site to NOP\n"); break; case FTRACE_BUG_CALL: pr_info("Setting ftrace call site to call ftrace function\n"); break; case FTRACE_BUG_UPDATE: pr_info("Updating ftrace call site to call a different ftrace function\n"); break; }}
/** * ftrace_bug - report and shutdown function tracer * @failed: The failed type (EFAULT, EINVAL, EPERM) * @rec: The record that failed * * The arch code that enables or disables the function tracing * can call ftrace_bug() when it has detected a problem in * modifying the code. @failed should be one of either: * EFAULT - if the problem happens on reading the @ip address * EINVAL - if what is read at @ip is not what was expected * EPERM - if the problem happens on writing to the @ip address */void ftrace_bug(int failed, struct dyn_ftrace *rec){ unsigned long ip = rec ? rec->ip : 0;
pr_info("------------[ ftrace bug ]------------\n");
switch (failed) { case -EFAULT: pr_info("ftrace faulted on modifying "); print_ip_sym(KERN_INFO, ip); break; case -EINVAL: pr_info("ftrace failed to modify "); print_ip_sym(KERN_INFO, ip); print_ip_ins(" actual: ", (unsigned char *)ip); pr_cont("\n"); if (ftrace_expected) { print_ip_ins(" expected: ", ftrace_expected); pr_cont("\n"); } break; case -EPERM: pr_info("ftrace faulted on writing "); print_ip_sym(KERN_INFO, ip); break; default: pr_info("ftrace faulted on unknown error "); print_ip_sym(KERN_INFO, ip); } print_bug_type(); if (rec) { struct ftrace_ops *ops = NULL;
pr_info("ftrace record flags: %lx\n", rec->flags); pr_cont(" (%ld)%s%s", ftrace_rec_count(rec), rec->flags & FTRACE_FL_REGS ? " R" : " ", rec->flags & FTRACE_FL_CALL_OPS ? " O" : " "); if (rec->flags & FTRACE_FL_TRAMP_EN) { ops = ftrace_find_tramp_ops_any(rec); if (ops) { do { pr_cont("\ttramp: %pS (%pS)", (void *)ops->trampoline, (void *)ops->func); ops = ftrace_find_tramp_ops_next(rec, ops); } while (ops); } else pr_cont("\ttramp: ERROR!");
} ip = ftrace_get_addr_curr(rec); pr_cont("\n expected tramp: %lx\n", ip); }
FTRACE_WARN_ON_ONCE(1);}
static int ftrace_check_record(struct dyn_ftrace *rec, bool enable, bool update){ unsigned long flag = 0UL;
ftrace_bug_type = FTRACE_BUG_UNKNOWN;
if (skip_record(rec)) return FTRACE_UPDATE_IGNORE;
/* * If we are updating calls: * * If the record has a ref count, then we need to enable it * because someone is using it. * * Otherwise we make sure its disabled. * * If we are disabling calls, then disable all records that * are enabled. */ if (enable && ftrace_rec_count(rec)) flag = FTRACE_FL_ENABLED;
/* * If enabling and the REGS flag does not match the REGS_EN, or * the TRAMP flag doesn't match the TRAMP_EN, then do not ignore * this record. Set flags to fail the compare against ENABLED. * Same for direct calls. */ if (flag) { if (!(rec->flags & FTRACE_FL_REGS) != !(rec->flags & FTRACE_FL_REGS_EN)) flag |= FTRACE_FL_REGS;
if (!(rec->flags & FTRACE_FL_TRAMP) != !(rec->flags & FTRACE_FL_TRAMP_EN)) flag |= FTRACE_FL_TRAMP;
/* * Direct calls are special, as count matters. * We must test the record for direct, if the * DIRECT and DIRECT_EN do not match, but only * if the count is 1. That's because, if the * count is something other than one, we do not * want the direct enabled (it will be done via the * direct helper). But if DIRECT_EN is set, and * the count is not one, we need to clear it. * */ if (ftrace_rec_count(rec) == 1) { if (!(rec->flags & FTRACE_FL_DIRECT) != !(rec->flags & FTRACE_FL_DIRECT_EN)) flag |= FTRACE_FL_DIRECT; } else if (rec->flags & FTRACE_FL_DIRECT_EN) { flag |= FTRACE_FL_DIRECT; }
/* * Ops calls are special, as count matters. * As with direct calls, they must only be enabled when count * is one, otherwise they'll be handled via the list ops. */ if (ftrace_rec_count(rec) == 1) { if (!(rec->flags & FTRACE_FL_CALL_OPS) != !(rec->flags & FTRACE_FL_CALL_OPS_EN)) flag |= FTRACE_FL_CALL_OPS; } else if (rec->flags & FTRACE_FL_CALL_OPS_EN) { flag |= FTRACE_FL_CALL_OPS; } }
/* If the state of this record hasn't changed, then do nothing */ if ((rec->flags & FTRACE_FL_ENABLED) == flag) return FTRACE_UPDATE_IGNORE;
if (flag) { /* Save off if rec is being enabled (for return value) */ flag ^= rec->flags & FTRACE_FL_ENABLED;
if (update) { rec->flags |= FTRACE_FL_ENABLED | FTRACE_FL_TOUCHED; if (flag & FTRACE_FL_REGS) { if (rec->flags & FTRACE_FL_REGS) rec->flags |= FTRACE_FL_REGS_EN; else rec->flags &= ~FTRACE_FL_REGS_EN; } if (flag & FTRACE_FL_TRAMP) { if (rec->flags & FTRACE_FL_TRAMP) rec->flags |= FTRACE_FL_TRAMP_EN; else rec->flags &= ~FTRACE_FL_TRAMP_EN; }
/* Keep track of anything that modifies the function */ if (rec->flags & (FTRACE_FL_DIRECT | FTRACE_FL_IPMODIFY)) rec->flags |= FTRACE_FL_MODIFIED;
if (flag & FTRACE_FL_DIRECT) { /* * If there's only one user (direct_ops helper) * then we can call the direct function * directly (no ftrace trampoline). */ if (ftrace_rec_count(rec) == 1) { if (rec->flags & FTRACE_FL_DIRECT) rec->flags |= FTRACE_FL_DIRECT_EN; else rec->flags &= ~FTRACE_FL_DIRECT_EN; } else { /* * Can only call directly if there's * only one callback to the function. */ rec->flags &= ~FTRACE_FL_DIRECT_EN; } }
if (flag & FTRACE_FL_CALL_OPS) { if (ftrace_rec_count(rec) == 1) { if (rec->flags & FTRACE_FL_CALL_OPS) rec->flags |= FTRACE_FL_CALL_OPS_EN; else rec->flags &= ~FTRACE_FL_CALL_OPS_EN; } else { /* * Can only call directly if there's * only one set of associated ops. */ rec->flags &= ~FTRACE_FL_CALL_OPS_EN; } } }
/* * If this record is being updated from a nop, then * return UPDATE_MAKE_CALL. * Otherwise, * return UPDATE_MODIFY_CALL to tell the caller to convert * from the save regs, to a non-save regs function or * vice versa, or from a trampoline call. */ if (flag & FTRACE_FL_ENABLED) { ftrace_bug_type = FTRACE_BUG_CALL; return FTRACE_UPDATE_MAKE_CALL; }
ftrace_bug_type = FTRACE_BUG_UPDATE; return FTRACE_UPDATE_MODIFY_CALL; }
if (update) { /* If there's no more users, clear all flags */ if (!ftrace_rec_count(rec)) rec->flags &= FTRACE_NOCLEAR_FLAGS; else /* * Just disable the record, but keep the ops TRAMP * and REGS states. The _EN flags must be disabled though. */ rec->flags &= ~(FTRACE_FL_ENABLED | FTRACE_FL_TRAMP_EN | FTRACE_FL_REGS_EN | FTRACE_FL_DIRECT_EN | FTRACE_FL_CALL_OPS_EN); }
ftrace_bug_type = FTRACE_BUG_NOP; return FTRACE_UPDATE_MAKE_NOP;}
/** * ftrace_update_record - set a record that now is tracing or not * @rec: the record to update * @enable: set to true if the record is tracing, false to force disable * * The records that represent all functions that can be traced need * to be updated when tracing has been enabled. */int ftrace_update_record(struct dyn_ftrace *rec, bool enable){ return ftrace_check_record(rec, enable, true);}
/** * ftrace_test_record - check if the record has been enabled or not * @rec: the record to test * @enable: set to true to check if enabled, false if it is disabled * * The arch code may need to test if a record is already set to * tracing to determine how to modify the function code that it * represents. */int ftrace_test_record(struct dyn_ftrace *rec, bool enable){ return ftrace_check_record(rec, enable, false);}
static struct ftrace_ops *ftrace_find_tramp_ops_any(struct dyn_ftrace *rec){ struct ftrace_ops *op; unsigned long ip = rec->ip;
do_for_each_ftrace_op(op, ftrace_ops_list) {
if (!op->trampoline) continue;
if (hash_contains_ip(ip, op->func_hash)) return op; } while_for_each_ftrace_op(op);
return NULL;}
static struct ftrace_ops *ftrace_find_tramp_ops_any_other(struct dyn_ftrace *rec, struct ftrace_ops *op_exclude){ struct ftrace_ops *op; unsigned long ip = rec->ip;
do_for_each_ftrace_op(op, ftrace_ops_list) {
if (op == op_exclude || !op->trampoline) continue;
if (hash_contains_ip(ip, op->func_hash)) return op; } while_for_each_ftrace_op(op);
return NULL;}
static struct ftrace_ops *ftrace_find_tramp_ops_next(struct dyn_ftrace *rec, struct ftrace_ops *op){ unsigned long ip = rec->ip;
while_for_each_ftrace_op(op) {
if (!op->trampoline) continue;
if (hash_contains_ip(ip, op->func_hash)) return op; }
return NULL;}
static struct ftrace_ops *ftrace_find_tramp_ops_curr(struct dyn_ftrace *rec){ struct ftrace_ops *op; unsigned long ip = rec->ip;
/* * Need to check removed ops first. * If they are being removed, and this rec has a tramp, * and this rec is in the ops list, then it would be the * one with the tramp. */ if (removed_ops) { if (hash_contains_ip(ip, &removed_ops->old_hash)) return removed_ops; }
/* * Need to find the current trampoline for a rec. * Now, a trampoline is only attached to a rec if there * was a single 'ops' attached to it. But this can be called * when we are adding another op to the rec or removing the * current one. Thus, if the op is being added, we can * ignore it because it hasn't attached itself to the rec * yet. * * If an ops is being modified (hooking to different functions) * then we don't care about the new functions that are being * added, just the old ones (that are probably being removed). * * If we are adding an ops to a function that already is using * a trampoline, it needs to be removed (trampolines are only * for single ops connected), then an ops that is not being * modified also needs to be checked. */ do_for_each_ftrace_op(op, ftrace_ops_list) {
if (!op->trampoline) continue;
/* * If the ops is being added, it hasn't gotten to * the point to be removed from this tree yet. */ if (op->flags & FTRACE_OPS_FL_ADDING) continue;
/* * If the ops is being modified and is in the old * hash, then it is probably being removed from this * function. */ if ((op->flags & FTRACE_OPS_FL_MODIFYING) && hash_contains_ip(ip, &op->old_hash)) return op; /* * If the ops is not being added or modified, and it's * in its normal filter hash, then this must be the one * we want! */ if (!(op->flags & FTRACE_OPS_FL_MODIFYING) && hash_contains_ip(ip, op->func_hash)) return op;
} while_for_each_ftrace_op(op);
return NULL;}
static struct ftrace_ops *ftrace_find_tramp_ops_new(struct dyn_ftrace *rec){ struct ftrace_ops *op; unsigned long ip = rec->ip;
do_for_each_ftrace_op(op, ftrace_ops_list) { /* pass rec in as regs to have non-NULL val */ if (hash_contains_ip(ip, op->func_hash)) return op; } while_for_each_ftrace_op(op);
return NULL;}
struct ftrace_ops *ftrace_find_unique_ops(struct dyn_ftrace *rec){ struct ftrace_ops *op, *found = NULL; unsigned long ip = rec->ip;
do_for_each_ftrace_op(op, ftrace_ops_list) {
if (hash_contains_ip(ip, op->func_hash)) { if (found) return NULL; found = op; }
} while_for_each_ftrace_op(op);
return found;}
#ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS/* Protected by rcu_tasks for reading, and direct_mutex for writing */static struct ftrace_hash __rcu *direct_functions = EMPTY_HASH;static DEFINE_MUTEX(direct_mutex);
/* * Search the direct_functions hash to see if the given instruction pointer * has a direct caller attached to it. */unsigned long ftrace_find_rec_direct(unsigned long ip){ struct ftrace_func_entry *entry;
entry = __ftrace_lookup_ip(direct_functions, ip); if (!entry) return 0;
return entry->direct;}
static void call_direct_funcs(unsigned long ip, unsigned long pip, struct ftrace_ops *ops, struct ftrace_regs *fregs){ unsigned long addr;
#ifdef CONFIG_HAVE_SINGLE_FTRACE_DIRECT_OPS addr = ftrace_find_rec_direct(ip);#else addr = READ_ONCE(ops->direct_call);#endif if (!addr) return;
arch_ftrace_set_direct_caller(fregs, addr);}#endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */
/** * ftrace_get_addr_new - Get the call address to set to * @rec: The ftrace record descriptor * * If the record has the FTRACE_FL_REGS set, that means that it * wants to convert to a callback that saves all regs. If FTRACE_FL_REGS * is not set, then it wants to convert to the normal callback. * * Returns: the address of the trampoline to set to */unsigned long ftrace_get_addr_new(struct dyn_ftrace *rec){ struct ftrace_ops *ops; unsigned long addr;
if ((rec->flags & FTRACE_FL_DIRECT) && (ftrace_rec_count(rec) == 1)) { addr = ftrace_find_rec_direct(rec->ip); if (addr) return addr; WARN_ON_ONCE(1); }
/* Trampolines take precedence over regs */ if (rec->flags & FTRACE_FL_TRAMP) { ops = ftrace_find_tramp_ops_new(rec); if (FTRACE_WARN_ON(!ops || !ops->trampoline)) { pr_warn("Bad trampoline accounting at: %p (%pS) (%lx)\n", (void *)rec->ip, (void *)rec->ip, rec->flags); /* Ftrace is shutting down, return anything */ return (unsigned long)FTRACE_ADDR; } return ops->trampoline; }
if (rec->flags & FTRACE_FL_REGS) return (unsigned long)FTRACE_REGS_ADDR; else return (unsigned long)FTRACE_ADDR;}
/** * ftrace_get_addr_curr - Get the call address that is already there * @rec: The ftrace record descriptor * * The FTRACE_FL_REGS_EN is set when the record already points to * a function that saves all the regs. Basically the '_EN' version * represents the current state of the function. * * Returns: the address of the trampoline that is currently being called */unsigned long ftrace_get_addr_curr(struct dyn_ftrace *rec){ struct ftrace_ops *ops; unsigned long addr;
/* Direct calls take precedence over trampolines */ if (rec->flags & FTRACE_FL_DIRECT_EN) { addr = ftrace_find_rec_direct(rec->ip); if (addr) return addr; WARN_ON_ONCE(1); }
/* Trampolines take precedence over regs */ if (rec->flags & FTRACE_FL_TRAMP_EN) { ops = ftrace_find_tramp_ops_curr(rec); if (FTRACE_WARN_ON(!ops)) { pr_warn("Bad trampoline accounting at: %p (%pS)\n", (void *)rec->ip, (void *)rec->ip); /* Ftrace is shutting down, return anything */ return (unsigned long)FTRACE_ADDR; } return ops->trampoline; }
if (rec->flags & FTRACE_FL_REGS_EN) return (unsigned long)FTRACE_REGS_ADDR; else return (unsigned long)FTRACE_ADDR;}
static int__ftrace_replace_code(struct dyn_ftrace *rec, bool enable){ unsigned long ftrace_old_addr; unsigned long ftrace_addr; int ret;
ftrace_addr = ftrace_get_addr_new(rec);
/* This needs to be done before we call ftrace_update_record */ ftrace_old_addr = ftrace_get_addr_curr(rec);
ret = ftrace_update_record(rec, enable);
ftrace_bug_type = FTRACE_BUG_UNKNOWN;
switch (ret) { case FTRACE_UPDATE_IGNORE: return 0;
case FTRACE_UPDATE_MAKE_CALL: ftrace_bug_type = FTRACE_BUG_CALL; return ftrace_make_call(rec, ftrace_addr);
case FTRACE_UPDATE_MAKE_NOP: ftrace_bug_type = FTRACE_BUG_NOP; return ftrace_make_nop(NULL, rec, ftrace_old_addr);
case FTRACE_UPDATE_MODIFY_CALL: ftrace_bug_type = FTRACE_BUG_UPDATE; return ftrace_modify_call(rec, ftrace_old_addr, ftrace_addr); }
return -1; /* unknown ftrace bug */}
void __weak ftrace_replace_code(int mod_flags){ struct dyn_ftrace *rec; struct ftrace_page *pg; bool enable = mod_flags & FTRACE_MODIFY_ENABLE_FL; int schedulable = mod_flags & FTRACE_MODIFY_MAY_SLEEP_FL; int failed;
if (unlikely(ftrace_disabled)) return;
do_for_each_ftrace_rec(pg, rec) {
if (skip_record(rec)) continue;
failed = __ftrace_replace_code(rec, enable); if (failed) { ftrace_bug(failed, rec); /* Stop processing */ return; } if (schedulable) cond_resched(); } while_for_each_ftrace_rec();}
struct ftrace_rec_iter { struct ftrace_page *pg; int index;};
/** * ftrace_rec_iter_start - start up iterating over traced functions * * Returns: an iterator handle that is used to iterate over all * the records that represent address locations where functions * are traced. * * May return NULL if no records are available. */struct ftrace_rec_iter *ftrace_rec_iter_start(void){ /* * We only use a single iterator. * Protected by the ftrace_lock mutex. */ static struct ftrace_rec_iter ftrace_rec_iter; struct ftrace_rec_iter *iter = &ftrace_rec_iter;
iter->pg = ftrace_pages_start; iter->index = 0;
/* Could have empty pages */ while (iter->pg && !iter->pg->index) iter->pg = iter->pg->next;
if (!iter->pg) return NULL;
return iter;}
/** * ftrace_rec_iter_next - get the next record to process. * @iter: The handle to the iterator. * * Returns: the next iterator after the given iterator @iter. */struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter){ iter->index++;
if (iter->index >= iter->pg->index) { iter->pg = iter->pg->next; iter->index = 0;
/* Could have empty pages */ while (iter->pg && !iter->pg->index) iter->pg = iter->pg->next; }
if (!iter->pg) return NULL;
return iter;}
/** * ftrace_rec_iter_record - get the record at the iterator location * @iter: The current iterator location * * Returns: the record that the current @iter is at. */struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter){ return &iter->pg->records[iter->index];}
static intftrace_nop_initialize(struct module *mod, struct dyn_ftrace *rec){ int ret;
if (unlikely(ftrace_disabled)) return 0;
ret = ftrace_init_nop(mod, rec); if (ret) { ftrace_bug_type = FTRACE_BUG_INIT; ftrace_bug(ret, rec); return 0; } return 1;}
/* * archs can override this function if they must do something * before the modifying code is performed. */void __weak ftrace_arch_code_modify_prepare(void){}
/* * archs can override this function if they must do something * after the modifying code is performed. */void __weak ftrace_arch_code_modify_post_process(void){}
static int update_ftrace_func(ftrace_func_t func){ static ftrace_func_t save_func;
/* Avoid updating if it hasn't changed */ if (func == save_func) return 0;
save_func = func;
return ftrace_update_ftrace_func(func);}
void ftrace_modify_all_code(int command){ int update = command & FTRACE_UPDATE_TRACE_FUNC; int mod_flags = 0; int err = 0;
if (command & FTRACE_MAY_SLEEP) mod_flags = FTRACE_MODIFY_MAY_SLEEP_FL;
/* * If the ftrace_caller calls a ftrace_ops func directly, * we need to make sure that it only traces functions it * expects to trace. When doing the switch of functions, * we need to update to the ftrace_ops_list_func first * before the transition between old and new calls are set, * as the ftrace_ops_list_func will check the ops hashes * to make sure the ops are having the right functions * traced. */ if (update) { err = update_ftrace_func(ftrace_ops_list_func); if (FTRACE_WARN_ON(err)) return; }
if (command & FTRACE_UPDATE_CALLS) ftrace_replace_code(mod_flags | FTRACE_MODIFY_ENABLE_FL); else if (command & FTRACE_DISABLE_CALLS) ftrace_replace_code(mod_flags);
if (update && ftrace_trace_function != ftrace_ops_list_func) { function_trace_op = set_function_trace_op; smp_wmb(); /* If irqs are disabled, we are in stop machine */ if (!irqs_disabled()) smp_call_function(ftrace_sync_ipi, NULL, 1); err = update_ftrace_func(ftrace_trace_function); if (FTRACE_WARN_ON(err)) return; }
if (command & FTRACE_START_FUNC_RET) err = ftrace_enable_ftrace_graph_caller(); else if (command & FTRACE_STOP_FUNC_RET) err = ftrace_disable_ftrace_graph_caller(); FTRACE_WARN_ON(err);}
static int __ftrace_modify_code(void *data){ int *command = data;
ftrace_modify_all_code(*command);
return 0;}
/** * ftrace_run_stop_machine - go back to the stop machine method * @command: The command to tell ftrace what to do * * If an arch needs to fall back to the stop machine method, the * it can call this function. */void ftrace_run_stop_machine(int command){ stop_machine(__ftrace_modify_code, &command, NULL);}
/** * arch_ftrace_update_code - modify the code to trace or not trace * @command: The command that needs to be done * * Archs can override this function if it does not need to * run stop_machine() to modify code. */void __weak arch_ftrace_update_code(int command){ ftrace_run_stop_machine(command);}
static void ftrace_run_update_code(int command){ ftrace_arch_code_modify_prepare();
/* * By default we use stop_machine() to modify the code. * But archs can do what ever they want as long as it * is safe. The stop_machine() is the safest, but also * produces the most overhead. */ arch_ftrace_update_code(command);
ftrace_arch_code_modify_post_process();}
static void ftrace_run_modify_code(struct ftrace_ops *ops, int command, struct ftrace_ops_hash *old_hash){ ops->flags |= FTRACE_OPS_FL_MODIFYING; ops->old_hash.filter_hash = old_hash->filter_hash; ops->old_hash.notrace_hash = old_hash->notrace_hash; ftrace_run_update_code(command); ops->old_hash.filter_hash = NULL; ops->old_hash.notrace_hash = NULL; ops->flags &= ~FTRACE_OPS_FL_MODIFYING;}
static ftrace_func_t saved_ftrace_func;static int ftrace_start_up;
void __weak arch_ftrace_trampoline_free(struct ftrace_ops *ops){}
/* List of trace_ops that have allocated trampolines */static LIST_HEAD(ftrace_ops_trampoline_list);
static void ftrace_add_trampoline_to_kallsyms(struct ftrace_ops *ops){ lockdep_assert_held(&ftrace_lock); list_add_rcu(&ops->list, &ftrace_ops_trampoline_list);}
static void ftrace_remove_trampoline_from_kallsyms(struct ftrace_ops *ops){ lockdep_assert_held(&ftrace_lock); list_del_rcu(&ops->list); synchronize_rcu();}
/* * "__builtin__ftrace" is used as a module name in /proc/kallsyms for symbols * for pages allocated for ftrace purposes, even though "__builtin__ftrace" is * not a module. */#define FTRACE_TRAMPOLINE_MOD "__builtin__ftrace"#define FTRACE_TRAMPOLINE_SYM "ftrace_trampoline"
static void ftrace_trampoline_free(struct ftrace_ops *ops){ if (ops && (ops->flags & FTRACE_OPS_FL_ALLOC_TRAMP) && ops->trampoline) { /* * Record the text poke event before the ksymbol unregister * event. */ perf_event_text_poke((void *)ops->trampoline, (void *)ops->trampoline, ops->trampoline_size, NULL, 0); perf_event_ksymbol(PERF_RECORD_KSYMBOL_TYPE_OOL, ops->trampoline, ops->trampoline_size, true, FTRACE_TRAMPOLINE_SYM); /* Remove from kallsyms after the perf events */ ftrace_remove_trampoline_from_kallsyms(ops); }
arch_ftrace_trampoline_free(ops);}
static void ftrace_startup_enable(int command){ if (saved_ftrace_func != ftrace_trace_function) { saved_ftrace_func = ftrace_trace_function; command |= FTRACE_UPDATE_TRACE_FUNC; }
if (!command || !ftrace_enabled) return;
ftrace_run_update_code(command);}
static void ftrace_startup_all(int command){ update_all_ops = true; ftrace_startup_enable(command); update_all_ops = false;}
int ftrace_startup(struct ftrace_ops *ops, int command){ int ret;
if (unlikely(ftrace_disabled)) return -ENODEV;
ret = __register_ftrace_function(ops); if (ret) return ret;
ftrace_start_up++;
/* * Note that ftrace probes uses this to start up * and modify functions it will probe. But we still * set the ADDING flag for modification, as probes * do not have trampolines. If they add them in the * future, then the probes will need to distinguish * between adding and updating probes. */ ops->flags |= FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_ADDING;
ret = ftrace_hash_ipmodify_enable(ops); if (ret < 0) { /* Rollback registration process */ __unregister_ftrace_function(ops); ftrace_start_up--; ops->flags &= ~FTRACE_OPS_FL_ENABLED; if (ops->flags & FTRACE_OPS_FL_DYNAMIC) ftrace_trampoline_free(ops); return ret; }
if (ftrace_hash_rec_enable(ops)) command |= FTRACE_UPDATE_CALLS;
ftrace_startup_enable(command);
/* * If ftrace is in an undefined state, we just remove ops from list * to prevent the NULL pointer, instead of totally rolling it back and * free trampoline, because those actions could cause further damage. */ if (unlikely(ftrace_disabled)) { __unregister_ftrace_function(ops); return -ENODEV; }
ops->flags &= ~FTRACE_OPS_FL_ADDING;
return 0;}
int ftrace_shutdown(struct ftrace_ops *ops, int command){ int ret;
if (unlikely(ftrace_disabled)) return -ENODEV;
ret = __unregister_ftrace_function(ops); if (ret) return ret;
ftrace_start_up--; /* * Just warn in case of unbalance, no need to kill ftrace, it's not * critical but the ftrace_call callers may be never nopped again after * further ftrace uses. */ WARN_ON_ONCE(ftrace_start_up < 0);
/* Disabling ipmodify never fails */ ftrace_hash_ipmodify_disable(ops);
if (ftrace_hash_rec_disable(ops)) command |= FTRACE_UPDATE_CALLS;
ops->flags &= ~FTRACE_OPS_FL_ENABLED;
if (saved_ftrace_func != ftrace_trace_function) { saved_ftrace_func = ftrace_trace_function; command |= FTRACE_UPDATE_TRACE_FUNC; }
if (!command || !ftrace_enabled) goto out;
/* * If the ops uses a trampoline, then it needs to be * tested first on update. */ ops->flags |= FTRACE_OPS_FL_REMOVING; removed_ops = ops;
/* The trampoline logic checks the old hashes */ ops->old_hash.filter_hash = ops->func_hash->filter_hash; ops->old_hash.notrace_hash = ops->func_hash->notrace_hash;
ftrace_run_update_code(command);
/* * If there's no more ops registered with ftrace, run a * sanity check to make sure all rec flags are cleared. */ if (rcu_dereference_protected(ftrace_ops_list, lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) { struct ftrace_page *pg; struct dyn_ftrace *rec;
do_for_each_ftrace_rec(pg, rec) { if (FTRACE_WARN_ON_ONCE(rec->flags & ~FTRACE_NOCLEAR_FLAGS)) pr_warn(" %pS flags:%lx\n", (void *)rec->ip, rec->flags); } while_for_each_ftrace_rec(); }
ops->old_hash.filter_hash = NULL; ops->old_hash.notrace_hash = NULL;
removed_ops = NULL; ops->flags &= ~FTRACE_OPS_FL_REMOVING;
out: /* * Dynamic ops may be freed, we must make sure that all * callers are done before leaving this function. */ if (ops->flags & FTRACE_OPS_FL_DYNAMIC) { /* * We need to do a hard force of sched synchronization. * This is because we use preempt_disable() to do RCU, but * the function tracers can be called where RCU is not watching * (like before user_exit()). We can not rely on the RCU * infrastructure to do the synchronization, thus we must do it * ourselves. */ synchronize_rcu_tasks_rude();
/* * When the kernel is preemptive, tasks can be preempted * while on a ftrace trampoline. Just scheduling a task on * a CPU is not good enough to flush them. Calling * synchronize_rcu_tasks() will wait for those tasks to * execute and either schedule voluntarily or enter user space. */ synchronize_rcu_tasks();
ftrace_trampoline_free(ops); }
return 0;}
/* Simply make a copy of @src and return it */static struct ftrace_hash *copy_hash(struct ftrace_hash *src){ if (ftrace_hash_empty(src)) return EMPTY_HASH;
return alloc_and_copy_ftrace_hash(src->size_bits, src);}
/* * Append @new_hash entries to @hash: * * If @hash is the EMPTY_HASH then it traces all functions and nothing * needs to be done. * * If @new_hash is the EMPTY_HASH, then make *hash the EMPTY_HASH so * that it traces everything. * * Otherwise, go through all of @new_hash and add anything that @hash * doesn't already have, to @hash. * * The filter_hash updates uses just the append_hash() function * and the notrace_hash does not. */static int append_hash(struct ftrace_hash **hash, struct ftrace_hash *new_hash, int size_bits){ struct ftrace_func_entry *entry; int size; int i;
if (*hash) { /* An empty hash does everything */ if (ftrace_hash_empty(*hash)) return 0; } else { *hash = alloc_ftrace_hash(size_bits); if (!*hash) return -ENOMEM; }
/* If new_hash has everything make hash have everything */ if (ftrace_hash_empty(new_hash)) { free_ftrace_hash(*hash); *hash = EMPTY_HASH; return 0; }
size = 1 << new_hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &new_hash->buckets[i], hlist) { /* Only add if not already in hash */ if (!__ftrace_lookup_ip(*hash, entry->ip) && add_hash_entry(*hash, entry->ip) == NULL) return -ENOMEM; } } return 0;}
/* * Remove functions from @hash that are in @notrace_hash */static void remove_hash(struct ftrace_hash *hash, struct ftrace_hash *notrace_hash){ struct ftrace_func_entry *entry; struct hlist_node *tmp; int size; int i;
/* If the notrace hash is empty, there's nothing to do */ if (ftrace_hash_empty(notrace_hash)) return;
size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry_safe(entry, tmp, &hash->buckets[i], hlist) { if (!__ftrace_lookup_ip(notrace_hash, entry->ip)) continue; remove_hash_entry(hash, entry); kfree(entry); } }}
/* * Add to @hash only those that are in both @new_hash1 and @new_hash2 * * The notrace_hash updates uses just the intersect_hash() function * and the filter_hash does not. */static int intersect_hash(struct ftrace_hash **hash, struct ftrace_hash *new_hash1, struct ftrace_hash *new_hash2){ struct ftrace_func_entry *entry; int size; int i;
/* * If new_hash1 or new_hash2 is the EMPTY_HASH then make the hash * empty as well as empty for notrace means none are notraced. */ if (ftrace_hash_empty(new_hash1) || ftrace_hash_empty(new_hash2)) { free_ftrace_hash(*hash); *hash = EMPTY_HASH; return 0; }
size = 1 << new_hash1->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &new_hash1->buckets[i], hlist) { /* Only add if in both @new_hash1 and @new_hash2 */ if (__ftrace_lookup_ip(new_hash2, entry->ip) && add_hash_entry(*hash, entry->ip) == NULL) return -ENOMEM; } } /* If nothing intersects, make it the empty set */ if (ftrace_hash_empty(*hash)) { free_ftrace_hash(*hash); *hash = EMPTY_HASH; } return 0;}
static bool ops_equal(struct ftrace_hash *A, struct ftrace_hash *B){ struct ftrace_func_entry *entry; int size; int i;
if (ftrace_hash_empty(A)) return ftrace_hash_empty(B);
if (ftrace_hash_empty(B)) return ftrace_hash_empty(A);
if (A->count != B->count) return false;
size = 1 << A->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &A->buckets[i], hlist) { if (!__ftrace_lookup_ip(B, entry->ip)) return false; } }
return true;}
static void ftrace_ops_update_code(struct ftrace_ops *ops, struct ftrace_ops_hash *old_hash);
static int __ftrace_hash_move_and_update_ops(struct ftrace_ops *ops, struct ftrace_hash **orig_hash, struct ftrace_hash *hash, int enable){ struct ftrace_ops_hash old_hash_ops; struct ftrace_hash *old_hash; int ret;
old_hash = *orig_hash; old_hash_ops.filter_hash = ops->func_hash->filter_hash; old_hash_ops.notrace_hash = ops->func_hash->notrace_hash; ret = ftrace_hash_move(ops, enable, orig_hash, hash); if (!ret) { ftrace_ops_update_code(ops, &old_hash_ops); free_ftrace_hash_rcu(old_hash); } return ret;}
static int ftrace_update_ops(struct ftrace_ops *ops, struct ftrace_hash *filter_hash, struct ftrace_hash *notrace_hash){ int ret;
if (!ops_equal(filter_hash, ops->func_hash->filter_hash)) { ret = __ftrace_hash_move_and_update_ops(ops, &ops->func_hash->filter_hash, filter_hash, 1); if (ret < 0) return ret; }
if (!ops_equal(notrace_hash, ops->func_hash->notrace_hash)) { ret = __ftrace_hash_move_and_update_ops(ops, &ops->func_hash->notrace_hash, notrace_hash, 0); if (ret < 0) return ret; }
return 0;}
static int add_first_hash(struct ftrace_hash **filter_hash, struct ftrace_hash **notrace_hash, struct ftrace_ops_hash *func_hash){ /* If the filter hash is not empty, simply remove the nohash from it */ if (!ftrace_hash_empty(func_hash->filter_hash)) { *filter_hash = copy_hash(func_hash->filter_hash); if (!*filter_hash) return -ENOMEM; remove_hash(*filter_hash, func_hash->notrace_hash); *notrace_hash = EMPTY_HASH;
} else { *notrace_hash = copy_hash(func_hash->notrace_hash); if (!*notrace_hash) return -ENOMEM; *filter_hash = EMPTY_HASH; } return 0;}
static int add_next_hash(struct ftrace_hash **filter_hash, struct ftrace_hash **notrace_hash, struct ftrace_ops_hash *ops_hash, struct ftrace_ops_hash *subops_hash){ int size_bits; int ret;
/* If the subops trace all functions so must the main ops */ if (ftrace_hash_empty(ops_hash->filter_hash) || ftrace_hash_empty(subops_hash->filter_hash)) { *filter_hash = EMPTY_HASH; } else { /* * The main ops filter hash is not empty, so its * notrace_hash had better be, as the notrace hash * is only used for empty main filter hashes. */ WARN_ON_ONCE(!ftrace_hash_empty(ops_hash->notrace_hash));
size_bits = max(ops_hash->filter_hash->size_bits, subops_hash->filter_hash->size_bits);
/* Copy the subops hash */ *filter_hash = alloc_and_copy_ftrace_hash(size_bits, subops_hash->filter_hash); if (!*filter_hash) return -ENOMEM; /* Remove any notrace functions from the copy */ remove_hash(*filter_hash, subops_hash->notrace_hash);
ret = append_hash(filter_hash, ops_hash->filter_hash, size_bits); if (ret < 0) { free_ftrace_hash(*filter_hash); *filter_hash = EMPTY_HASH; return ret; } }
/* * Only process notrace hashes if the main filter hash is empty * (tracing all functions), otherwise the filter hash will just * remove the notrace hash functions, and the notrace hash is * not needed. */ if (ftrace_hash_empty(*filter_hash)) { /* * Intersect the notrace functions. That is, if two * subops are not tracing a set of functions, the * main ops will only not trace the functions that are * in both subops, but has to trace the functions that * are only notrace in one of the subops, for the other * subops to be able to trace them. */ size_bits = max(ops_hash->notrace_hash->size_bits, subops_hash->notrace_hash->size_bits); *notrace_hash = alloc_ftrace_hash(size_bits); if (!*notrace_hash) return -ENOMEM;
ret = intersect_hash(notrace_hash, ops_hash->notrace_hash, subops_hash->notrace_hash); if (ret < 0) { free_ftrace_hash(*notrace_hash); *notrace_hash = EMPTY_HASH; return ret; } } return 0;}
/** * ftrace_startup_subops - enable tracing for subops of an ops * @ops: Manager ops (used to pick all the functions of its subops) * @subops: A new ops to add to @ops * @command: Extra commands to use to enable tracing * * The @ops is a manager @ops that has the filter that includes all the functions * that its list of subops are tracing. Adding a new @subops will add the * functions of @subops to @ops. */int ftrace_startup_subops(struct ftrace_ops *ops, struct ftrace_ops *subops, int command){ struct ftrace_hash *filter_hash = EMPTY_HASH; struct ftrace_hash *notrace_hash = EMPTY_HASH; struct ftrace_hash *save_filter_hash; struct ftrace_hash *save_notrace_hash; int ret;
if (unlikely(ftrace_disabled)) return -ENODEV;
ftrace_ops_init(ops); ftrace_ops_init(subops);
if (WARN_ON_ONCE(subops->flags & FTRACE_OPS_FL_ENABLED)) return -EBUSY;
/* Make everything canonical (Just in case!) */ if (!ops->func_hash->filter_hash) ops->func_hash->filter_hash = EMPTY_HASH; if (!ops->func_hash->notrace_hash) ops->func_hash->notrace_hash = EMPTY_HASH; if (!subops->func_hash->filter_hash) subops->func_hash->filter_hash = EMPTY_HASH; if (!subops->func_hash->notrace_hash) subops->func_hash->notrace_hash = EMPTY_HASH;
/* For the first subops to ops just enable it normally */ if (list_empty(&ops->subop_list)) {
/* The ops was empty, should have empty hashes */ WARN_ON_ONCE(!ftrace_hash_empty(ops->func_hash->filter_hash)); WARN_ON_ONCE(!ftrace_hash_empty(ops->func_hash->notrace_hash));
ret = add_first_hash(&filter_hash, ¬race_hash, subops->func_hash); if (ret < 0) return ret;
save_filter_hash = ops->func_hash->filter_hash; save_notrace_hash = ops->func_hash->notrace_hash;
ops->func_hash->filter_hash = filter_hash; ops->func_hash->notrace_hash = notrace_hash; list_add(&subops->list, &ops->subop_list); ret = ftrace_startup(ops, command); if (ret < 0) { list_del(&subops->list); ops->func_hash->filter_hash = save_filter_hash; ops->func_hash->notrace_hash = save_notrace_hash; free_ftrace_hash(filter_hash); free_ftrace_hash(notrace_hash); } else { free_ftrace_hash(save_filter_hash); free_ftrace_hash(save_notrace_hash); subops->flags |= FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_SUBOP; subops->managed = ops; } return ret; }
/* * Here there's already something attached. Here are the rules: * If the new subops and main ops filter hashes are not empty: * o Make a copy of the subops filter hash * o Remove all functions in the nohash from it. * o Add in the main hash filter functions * o Remove any of these functions from the main notrace hash */
ret = add_next_hash(&filter_hash, ¬race_hash, ops->func_hash, subops->func_hash); if (ret < 0) return ret;
list_add(&subops->list, &ops->subop_list);
ret = ftrace_update_ops(ops, filter_hash, notrace_hash); free_ftrace_hash(filter_hash); free_ftrace_hash(notrace_hash); if (ret < 0) { list_del(&subops->list); } else { subops->flags |= FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_SUBOP; subops->managed = ops; } return ret;}
static int rebuild_hashes(struct ftrace_hash **filter_hash, struct ftrace_hash **notrace_hash, struct ftrace_ops *ops){ struct ftrace_ops_hash temp_hash; struct ftrace_ops *subops; bool first = true; int ret;
temp_hash.filter_hash = EMPTY_HASH; temp_hash.notrace_hash = EMPTY_HASH;
list_for_each_entry(subops, &ops->subop_list, list) { *filter_hash = EMPTY_HASH; *notrace_hash = EMPTY_HASH;
if (first) { ret = add_first_hash(filter_hash, notrace_hash, subops->func_hash); if (ret < 0) return ret; first = false; } else { ret = add_next_hash(filter_hash, notrace_hash, &temp_hash, subops->func_hash); if (ret < 0) { free_ftrace_hash(temp_hash.filter_hash); free_ftrace_hash(temp_hash.notrace_hash); return ret; } }
free_ftrace_hash(temp_hash.filter_hash); free_ftrace_hash(temp_hash.notrace_hash);
temp_hash.filter_hash = *filter_hash; temp_hash.notrace_hash = *notrace_hash; } return 0;}
/** * ftrace_shutdown_subops - Remove a subops from a manager ops * @ops: A manager ops to remove @subops from * @subops: The subops to remove from @ops * @command: Any extra command flags to add to modifying the text * * Removes the functions being traced by the @subops from @ops. Note, it * will not affect functions that are being traced by other subops that * still exist in @ops. * * If the last subops is removed from @ops, then @ops is shutdown normally. */int ftrace_shutdown_subops(struct ftrace_ops *ops, struct ftrace_ops *subops, int command){ struct ftrace_hash *filter_hash = EMPTY_HASH; struct ftrace_hash *notrace_hash = EMPTY_HASH; int ret;
if (unlikely(ftrace_disabled)) return -ENODEV;
if (WARN_ON_ONCE(!(subops->flags & FTRACE_OPS_FL_ENABLED))) return -EINVAL;
list_del(&subops->list);
if (list_empty(&ops->subop_list)) { /* Last one, just disable the current ops */
ret = ftrace_shutdown(ops, command); if (ret < 0) { list_add(&subops->list, &ops->subop_list); return ret; }
subops->flags &= ~FTRACE_OPS_FL_ENABLED;
free_ftrace_hash(ops->func_hash->filter_hash); free_ftrace_hash(ops->func_hash->notrace_hash); ops->func_hash->filter_hash = EMPTY_HASH; ops->func_hash->notrace_hash = EMPTY_HASH; subops->flags &= ~(FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_SUBOP); subops->managed = NULL;
return 0; }
/* Rebuild the hashes without subops */ ret = rebuild_hashes(&filter_hash, ¬race_hash, ops); if (ret < 0) return ret;
ret = ftrace_update_ops(ops, filter_hash, notrace_hash); if (ret < 0) { list_add(&subops->list, &ops->subop_list); } else { subops->flags &= ~(FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_SUBOP); subops->managed = NULL; } free_ftrace_hash(filter_hash); free_ftrace_hash(notrace_hash); return ret;}
static int ftrace_hash_move_and_update_subops(struct ftrace_ops *subops, struct ftrace_hash **orig_subhash, struct ftrace_hash *hash){ struct ftrace_ops *ops = subops->managed; struct ftrace_hash *notrace_hash; struct ftrace_hash *filter_hash; struct ftrace_hash *save_hash; struct ftrace_hash *new_hash; int ret;
/* Manager ops can not be subops (yet) */ if (WARN_ON_ONCE(!ops || ops->flags & FTRACE_OPS_FL_SUBOP)) return -EINVAL;
/* Move the new hash over to the subops hash */ save_hash = *orig_subhash; *orig_subhash = __ftrace_hash_move(hash); if (!*orig_subhash) { *orig_subhash = save_hash; return -ENOMEM; }
ret = rebuild_hashes(&filter_hash, ¬race_hash, ops); if (!ret) { ret = ftrace_update_ops(ops, filter_hash, notrace_hash); free_ftrace_hash(filter_hash); free_ftrace_hash(notrace_hash); }
if (ret) { /* Put back the original hash */ new_hash = *orig_subhash; *orig_subhash = save_hash; free_ftrace_hash_rcu(new_hash); } else { free_ftrace_hash_rcu(save_hash); } return ret;}
u64 ftrace_update_time;u64 ftrace_total_mod_time;unsigned long ftrace_update_tot_cnt;unsigned long ftrace_number_of_pages;unsigned long ftrace_number_of_groups;
static inline int ops_traces_mod(struct ftrace_ops *ops){ /* * Filter_hash being empty will default to trace module. * But notrace hash requires a test of individual module functions. */ return ftrace_hash_empty(ops->func_hash->filter_hash) && ftrace_hash_empty(ops->func_hash->notrace_hash);}
static int ftrace_update_code(struct module *mod, struct ftrace_page *new_pgs){ bool init_nop = ftrace_need_init_nop(); struct ftrace_page *pg; struct dyn_ftrace *p; u64 start, stop, update_time; unsigned long update_cnt = 0; unsigned long rec_flags = 0; int i;
start = ftrace_now(raw_smp_processor_id());
/* * When a module is loaded, this function is called to convert * the calls to mcount in its text to nops, and also to create * an entry in the ftrace data. Now, if ftrace is activated * after this call, but before the module sets its text to * read-only, the modification of enabling ftrace can fail if * the read-only is done while ftrace is converting the calls. * To prevent this, the module's records are set as disabled * and will be enabled after the call to set the module's text * to read-only. */ if (mod) rec_flags |= FTRACE_FL_DISABLED;
for (pg = new_pgs; pg; pg = pg->next) {
for (i = 0; i < pg->index; i++) {
/* If something went wrong, bail without enabling anything */ if (unlikely(ftrace_disabled)) return -1;
p = &pg->records[i]; p->flags = rec_flags;
/* * Do the initial record conversion from mcount jump * to the NOP instructions. */ if (init_nop && !ftrace_nop_initialize(mod, p)) break;
update_cnt++; } }
stop = ftrace_now(raw_smp_processor_id()); update_time = stop - start; if (mod) ftrace_total_mod_time += update_time; else ftrace_update_time = update_time; ftrace_update_tot_cnt += update_cnt;
return 0;}
static int ftrace_allocate_records(struct ftrace_page *pg, int count, unsigned long *num_pages){ int order; int pages; int cnt;
if (WARN_ON(!count)) return -EINVAL;
/* We want to fill as much as possible, with no empty pages */ pages = DIV_ROUND_UP(count * ENTRY_SIZE, PAGE_SIZE); order = fls(pages) - 1;
again: pg->records = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, order);
if (!pg->records) { /* if we can't allocate this size, try something smaller */ if (!order) return -ENOMEM; order--; goto again; }
ftrace_number_of_pages += 1 << order; *num_pages += 1 << order; ftrace_number_of_groups++;
cnt = ENTRIES_PER_PAGE_GROUP(order); pg->order = order;
if (cnt > count) cnt = count;
return cnt;}
static void ftrace_free_pages(struct ftrace_page *pages){ struct ftrace_page *pg = pages;
while (pg) { if (pg->records) { free_pages((unsigned long)pg->records, pg->order); ftrace_number_of_pages -= 1 << pg->order; } pages = pg->next; kfree(pg); pg = pages; ftrace_number_of_groups--; }}
static struct ftrace_page *ftrace_allocate_pages(unsigned long num_to_init, unsigned long *num_pages){ struct ftrace_page *start_pg; struct ftrace_page *pg; int cnt;
*num_pages = 0;
if (!num_to_init) return NULL;
start_pg = pg = kzalloc_obj(*pg); if (!pg) return NULL;
/* * Try to allocate as much as possible in one continues * location that fills in all of the space. We want to * waste as little space as possible. */ for (;;) { cnt = ftrace_allocate_records(pg, num_to_init, num_pages); if (cnt < 0) goto free_pages;
num_to_init -= cnt; if (!num_to_init) break;
pg->next = kzalloc_obj(*pg); if (!pg->next) goto free_pages;
pg = pg->next; }
return start_pg;
free_pages: ftrace_free_pages(start_pg); pr_info("ftrace: FAILED to allocate memory for functions\n"); return NULL;}
#define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
struct ftrace_iterator { loff_t pos; loff_t func_pos; loff_t mod_pos; struct ftrace_page *pg; struct dyn_ftrace *func; struct ftrace_func_probe *probe; struct ftrace_func_entry *probe_entry; struct trace_parser parser; struct ftrace_hash *hash; struct ftrace_ops *ops; struct trace_array *tr; struct list_head *mod_list; int pidx; int idx; unsigned flags;};
static void *t_probe_next(struct seq_file *m, loff_t *pos){ struct ftrace_iterator *iter = m->private; struct trace_array *tr = iter->ops->private; struct list_head *func_probes; struct ftrace_hash *hash; struct list_head *next; struct hlist_node *hnd = NULL; struct hlist_head *hhd; int size;
(*pos)++; iter->pos = *pos;
if (!tr) return NULL;
func_probes = &tr->func_probes; if (list_empty(func_probes)) return NULL;
if (!iter->probe) { next = func_probes->next; iter->probe = list_entry(next, struct ftrace_func_probe, list); }
if (iter->probe_entry) hnd = &iter->probe_entry->hlist;
hash = iter->probe->ops.func_hash->filter_hash;
/* * A probe being registered may temporarily have an empty hash * and it's at the end of the func_probes list. */ if (!hash || hash == EMPTY_HASH) return NULL;
size = 1 << hash->size_bits;
retry: if (iter->pidx >= size) { if (iter->probe->list.next == func_probes) return NULL; next = iter->probe->list.next; iter->probe = list_entry(next, struct ftrace_func_probe, list); hash = iter->probe->ops.func_hash->filter_hash; size = 1 << hash->size_bits; iter->pidx = 0; }
hhd = &hash->buckets[iter->pidx];
if (hlist_empty(hhd)) { iter->pidx++; hnd = NULL; goto retry; }
if (!hnd) hnd = hhd->first; else { hnd = hnd->next; if (!hnd) { iter->pidx++; goto retry; } }
if (WARN_ON_ONCE(!hnd)) return NULL;
iter->probe_entry = hlist_entry(hnd, struct ftrace_func_entry, hlist);
return iter;}
static void *t_probe_start(struct seq_file *m, loff_t *pos){ struct ftrace_iterator *iter = m->private; void *p = NULL; loff_t l;
if (!(iter->flags & FTRACE_ITER_DO_PROBES)) return NULL;
if (iter->mod_pos > *pos) return NULL;
iter->probe = NULL; iter->probe_entry = NULL; iter->pidx = 0; for (l = 0; l <= (*pos - iter->mod_pos); ) { p = t_probe_next(m, &l); if (!p) break; } if (!p) return NULL;
/* Only set this if we have an item */ iter->flags |= FTRACE_ITER_PROBE;
return iter;}
static intt_probe_show(struct seq_file *m, struct ftrace_iterator *iter){ struct ftrace_func_entry *probe_entry; struct ftrace_probe_ops *probe_ops; struct ftrace_func_probe *probe;
probe = iter->probe; probe_entry = iter->probe_entry;
if (WARN_ON_ONCE(!probe || !probe_entry)) return -EIO;
probe_ops = probe->probe_ops;
if (probe_ops->print) return probe_ops->print(m, probe_entry->ip, probe_ops, probe->data);
seq_printf(m, "%ps:%ps\n", (void *)probe_entry->ip, (void *)probe_ops->func);
return 0;}
static void *t_mod_next(struct seq_file *m, loff_t *pos){ struct ftrace_iterator *iter = m->private; struct trace_array *tr = iter->tr;
(*pos)++; iter->pos = *pos;
iter->mod_list = iter->mod_list->next;
if (iter->mod_list == &tr->mod_trace || iter->mod_list == &tr->mod_notrace) { iter->flags &= ~FTRACE_ITER_MOD; return NULL; }
iter->mod_pos = *pos;
return iter;}
static void *t_mod_start(struct seq_file *m, loff_t *pos){ struct ftrace_iterator *iter = m->private; void *p = NULL; loff_t l;
if (iter->func_pos > *pos) return NULL;
iter->mod_pos = iter->func_pos;
/* probes are only available if tr is set */ if (!iter->tr) return NULL;
for (l = 0; l <= (*pos - iter->func_pos); ) { p = t_mod_next(m, &l); if (!p) break; } if (!p) { iter->flags &= ~FTRACE_ITER_MOD; return t_probe_start(m, pos); }
/* Only set this if we have an item */ iter->flags |= FTRACE_ITER_MOD;
return iter;}
static intt_mod_show(struct seq_file *m, struct ftrace_iterator *iter){ struct ftrace_mod_load *ftrace_mod; struct trace_array *tr = iter->tr;
if (WARN_ON_ONCE(!iter->mod_list) || iter->mod_list == &tr->mod_trace || iter->mod_list == &tr->mod_notrace) return -EIO;
ftrace_mod = list_entry(iter->mod_list, struct ftrace_mod_load, list);
if (ftrace_mod->func) seq_printf(m, "%s", ftrace_mod->func); else seq_putc(m, '*');
seq_printf(m, ":mod:%s\n", ftrace_mod->module);
return 0;}
static void *t_func_next(struct seq_file *m, loff_t *pos){ struct ftrace_iterator *iter = m->private; struct dyn_ftrace *rec = NULL;
(*pos)++;
retry: if (iter->idx >= iter->pg->index) { if (iter->pg->next) { iter->pg = iter->pg->next; iter->idx = 0; goto retry; } } else { rec = &iter->pg->records[iter->idx++]; if (((iter->flags & (FTRACE_ITER_FILTER | FTRACE_ITER_NOTRACE)) && !ftrace_lookup_ip(iter->hash, rec->ip)) ||
((iter->flags & FTRACE_ITER_ENABLED) && !(rec->flags & FTRACE_FL_ENABLED)) ||
((iter->flags & FTRACE_ITER_TOUCHED) && !(rec->flags & FTRACE_FL_TOUCHED))) {
rec = NULL; goto retry; } }
if (!rec) return NULL;
iter->pos = iter->func_pos = *pos; iter->func = rec;
return iter;}
static void *t_next(struct seq_file *m, void *v, loff_t *pos){ struct ftrace_iterator *iter = m->private; loff_t l = *pos; /* t_probe_start() must use original pos */ void *ret;
if (unlikely(ftrace_disabled)) return NULL;
if (iter->flags & FTRACE_ITER_PROBE) return t_probe_next(m, pos);
if (iter->flags & FTRACE_ITER_MOD) return t_mod_next(m, pos);
if (iter->flags & FTRACE_ITER_PRINTALL) { /* next must increment pos, and t_probe_start does not */ (*pos)++; return t_mod_start(m, &l); }
ret = t_func_next(m, pos);
if (!ret) return t_mod_start(m, &l);
return ret;}
static void reset_iter_read(struct ftrace_iterator *iter){ iter->pos = 0; iter->func_pos = 0; iter->flags &= ~(FTRACE_ITER_PRINTALL | FTRACE_ITER_PROBE | FTRACE_ITER_MOD);}
static void *t_start(struct seq_file *m, loff_t *pos){ struct ftrace_iterator *iter = m->private; void *p = NULL; loff_t l;
mutex_lock(&ftrace_lock);
if (unlikely(ftrace_disabled)) return NULL;
/* * If an lseek was done, then reset and start from beginning. */ if (*pos < iter->pos) reset_iter_read(iter);
/* * For set_ftrace_filter reading, if we have the filter * off, we can short cut and just print out that all * functions are enabled. */ if ((iter->flags & (FTRACE_ITER_FILTER | FTRACE_ITER_NOTRACE)) && ftrace_hash_empty(iter->hash)) { iter->func_pos = 1; /* Account for the message */ if (*pos > 0) return t_mod_start(m, pos); iter->flags |= FTRACE_ITER_PRINTALL; /* reset in case of seek/pread */ iter->flags &= ~FTRACE_ITER_PROBE; return iter; }
if (iter->flags & FTRACE_ITER_MOD) return t_mod_start(m, pos);
/* * Unfortunately, we need to restart at ftrace_pages_start * every time we let go of the ftrace_mutex. This is because * those pointers can change without the lock. */ iter->pg = ftrace_pages_start; iter->idx = 0; for (l = 0; l <= *pos; ) { p = t_func_next(m, &l); if (!p) break; }
if (!p) return t_mod_start(m, pos);
return iter;}
static void t_stop(struct seq_file *m, void *p){ mutex_unlock(&ftrace_lock);}
void * __weakarch_ftrace_trampoline_func(struct ftrace_ops *ops, struct dyn_ftrace *rec){ return NULL;}
static void add_trampoline_func(struct seq_file *m, struct ftrace_ops *ops, struct dyn_ftrace *rec){ void *ptr;
ptr = arch_ftrace_trampoline_func(ops, rec); if (ptr) seq_printf(m, " ->%pS", ptr);}
#ifdef FTRACE_MCOUNT_MAX_OFFSET/* * Weak functions can still have an mcount/fentry that is saved in * the __mcount_loc section. These can be detected by having a * symbol offset of greater than FTRACE_MCOUNT_MAX_OFFSET, as the * symbol found by kallsyms is not the function that the mcount/fentry * is part of. The offset is much greater in these cases. * * Test the record to make sure that the ip points to a valid kallsyms * and if not, mark it disabled. */static int test_for_valid_rec(struct dyn_ftrace *rec){ char str[KSYM_SYMBOL_LEN]; unsigned long offset; const char *ret;
ret = kallsyms_lookup(rec->ip, NULL, &offset, NULL, str);
/* Weak functions can cause invalid addresses */ if (!ret || offset > FTRACE_MCOUNT_MAX_OFFSET) { rec->flags |= FTRACE_FL_DISABLED; return 0; } return 1;}
static struct workqueue_struct *ftrace_check_wq __initdata;static struct work_struct ftrace_check_work __initdata;
/* * Scan all the mcount/fentry entries to make sure they are valid. */static __init void ftrace_check_work_func(struct work_struct *work){ struct ftrace_page *pg; struct dyn_ftrace *rec;
mutex_lock(&ftrace_lock); do_for_each_ftrace_rec(pg, rec) { test_for_valid_rec(rec); } while_for_each_ftrace_rec(); mutex_unlock(&ftrace_lock);}
static int __init ftrace_check_for_weak_functions(void){ INIT_WORK(&ftrace_check_work, ftrace_check_work_func);
ftrace_check_wq = alloc_workqueue("ftrace_check_wq", WQ_UNBOUND, 0);
queue_work(ftrace_check_wq, &ftrace_check_work); return 0;}
static int __init ftrace_check_sync(void){ /* Make sure the ftrace_check updates are finished */ if (ftrace_check_wq) destroy_workqueue(ftrace_check_wq); return 0;}
late_initcall_sync(ftrace_check_sync);subsys_initcall(ftrace_check_for_weak_functions);
static int print_rec(struct seq_file *m, unsigned long ip){ unsigned long offset; char str[KSYM_SYMBOL_LEN]; char *modname; const char *ret;
ret = kallsyms_lookup(ip, NULL, &offset, &modname, str); /* Weak functions can cause invalid addresses */ if (!ret || offset > FTRACE_MCOUNT_MAX_OFFSET) { snprintf(str, KSYM_SYMBOL_LEN, "%s_%ld", FTRACE_INVALID_FUNCTION, offset); ret = NULL; }
seq_puts(m, str); if (modname) seq_printf(m, " [%s]", modname); return ret == NULL ? -1 : 0;}#elsestatic inline int test_for_valid_rec(struct dyn_ftrace *rec){ return 1;}
static inline int print_rec(struct seq_file *m, unsigned long ip){ seq_printf(m, "%ps", (void *)ip); return 0;}#endif
static void print_subops(struct seq_file *m, struct ftrace_ops *ops, struct dyn_ftrace *rec){ struct ftrace_ops *subops; bool first = true;
list_for_each_entry(subops, &ops->subop_list, list) { if (!((subops->flags & FTRACE_OPS_FL_ENABLED) && hash_contains_ip(rec->ip, subops->func_hash))) continue; if (first) { seq_printf(m, "\tsubops:"); first = false; }#ifdef CONFIG_FUNCTION_GRAPH_TRACER if (subops->flags & FTRACE_OPS_FL_GRAPH) { struct fgraph_ops *gops;
gops = container_of(subops, struct fgraph_ops, ops); seq_printf(m, " {ent:%pS ret:%pS}", (void *)gops->entryfunc, (void *)gops->retfunc); continue; }#endif if (subops->trampoline) { seq_printf(m, " {%pS (%pS)}", (void *)subops->trampoline, (void *)subops->func); add_trampoline_func(m, subops, rec); } else { seq_printf(m, " {%pS}", (void *)subops->func); } }}
static int t_show(struct seq_file *m, void *v){ struct ftrace_iterator *iter = m->private; struct dyn_ftrace *rec;
if (iter->flags & FTRACE_ITER_PROBE) return t_probe_show(m, iter);
if (iter->flags & FTRACE_ITER_MOD) return t_mod_show(m, iter);
if (iter->flags & FTRACE_ITER_PRINTALL) { if (iter->flags & FTRACE_ITER_NOTRACE) seq_puts(m, "#### no functions disabled ####\n"); else seq_puts(m, "#### all functions enabled ####\n"); return 0; }
rec = iter->func;
if (!rec) return 0;
if (iter->flags & FTRACE_ITER_ADDRS) seq_printf(m, "%lx ", rec->ip);
if (print_rec(m, rec->ip)) { /* This should only happen when a rec is disabled */ WARN_ON_ONCE(!(rec->flags & FTRACE_FL_DISABLED)); seq_putc(m, '\n'); return 0; }
if (iter->flags & (FTRACE_ITER_ENABLED | FTRACE_ITER_TOUCHED)) { struct ftrace_ops *ops;
seq_printf(m, " (%ld)%s%s%s%s%s", ftrace_rec_count(rec), rec->flags & FTRACE_FL_REGS ? " R" : " ", rec->flags & FTRACE_FL_IPMODIFY ? " I" : " ", rec->flags & FTRACE_FL_DIRECT ? " D" : " ", rec->flags & FTRACE_FL_CALL_OPS ? " O" : " ", rec->flags & FTRACE_FL_MODIFIED ? " M " : " "); if (rec->flags & FTRACE_FL_TRAMP_EN) { ops = ftrace_find_tramp_ops_any(rec); if (ops) { do { seq_printf(m, "\ttramp: %pS (%pS)", (void *)ops->trampoline, (void *)ops->func); add_trampoline_func(m, ops, rec); print_subops(m, ops, rec); ops = ftrace_find_tramp_ops_next(rec, ops); } while (ops); } else seq_puts(m, "\ttramp: ERROR!"); } else { add_trampoline_func(m, NULL, rec); } if (rec->flags & FTRACE_FL_CALL_OPS_EN) { ops = ftrace_find_unique_ops(rec); if (ops) { seq_printf(m, "\tops: %pS (%pS)", ops, ops->func); print_subops(m, ops, rec); } else { seq_puts(m, "\tops: ERROR!"); } } if (rec->flags & FTRACE_FL_DIRECT) { unsigned long direct;
direct = ftrace_find_rec_direct(rec->ip); if (direct) { seq_printf(m, "\n\tdirect%s-->%pS", ftrace_is_jmp(direct) ? "(jmp)" : "", (void *)ftrace_jmp_get(direct)); } } }
seq_putc(m, '\n');
return 0;}
static const struct seq_operations show_ftrace_seq_ops = { .start = t_start, .next = t_next, .stop = t_stop, .show = t_show,};
static intftrace_avail_open(struct inode *inode, struct file *file){ struct ftrace_iterator *iter; int ret;
ret = security_locked_down(LOCKDOWN_TRACEFS); if (ret) return ret;
if (unlikely(ftrace_disabled)) return -ENODEV;
iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter)); if (!iter) return -ENOMEM;
iter->pg = ftrace_pages_start; iter->ops = &global_ops;
return 0;}
static intftrace_enabled_open(struct inode *inode, struct file *file){ struct ftrace_iterator *iter;
/* * This shows us what functions are currently being * traced and by what. Not sure if we want lockdown * to hide such critical information for an admin. * Although, perhaps it can show information we don't * want people to see, but if something is tracing * something, we probably want to know about it. */
iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter)); if (!iter) return -ENOMEM;
iter->pg = ftrace_pages_start; iter->flags = FTRACE_ITER_ENABLED; iter->ops = &global_ops;
return 0;}
static intftrace_touched_open(struct inode *inode, struct file *file){ struct ftrace_iterator *iter;
/* * This shows us what functions have ever been enabled * (traced, direct, patched, etc). Not sure if we want lockdown * to hide such critical information for an admin. * Although, perhaps it can show information we don't * want people to see, but if something had traced * something, we probably want to know about it. */
iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter)); if (!iter) return -ENOMEM;
iter->pg = ftrace_pages_start; iter->flags = FTRACE_ITER_TOUCHED; iter->ops = &global_ops;
return 0;}
static intftrace_avail_addrs_open(struct inode *inode, struct file *file){ struct ftrace_iterator *iter; int ret;
ret = security_locked_down(LOCKDOWN_TRACEFS); if (ret) return ret;
if (unlikely(ftrace_disabled)) return -ENODEV;
iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter)); if (!iter) return -ENOMEM;
iter->pg = ftrace_pages_start; iter->flags = FTRACE_ITER_ADDRS; iter->ops = &global_ops;
return 0;}
/** * ftrace_regex_open - initialize function tracer filter files * @ops: The ftrace_ops that hold the hash filters * @flag: The type of filter to process * @inode: The inode, usually passed in to your open routine * @file: The file, usually passed in to your open routine * * ftrace_regex_open() initializes the filter files for the * @ops. Depending on @flag it may process the filter hash or * the notrace hash of @ops. With this called from the open * routine, you can use ftrace_filter_write() for the write * routine if @flag has FTRACE_ITER_FILTER set, or * ftrace_notrace_write() if @flag has FTRACE_ITER_NOTRACE set. * tracing_lseek() should be used as the lseek routine, and * release must call ftrace_regex_release(). * * Returns: 0 on success or a negative errno value on failure */intftrace_regex_open(struct ftrace_ops *ops, int flag, struct inode *inode, struct file *file){ struct ftrace_iterator *iter; struct ftrace_hash *hash; struct list_head *mod_head; struct trace_array *tr = ops->private; int ret = -ENOMEM;
ftrace_ops_init(ops);
if (unlikely(ftrace_disabled)) return -ENODEV;
if (tracing_check_open_get_tr(tr)) return -ENODEV;
iter = kzalloc_obj(*iter); if (!iter) goto out;
if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX)) goto out;
iter->ops = ops; iter->flags = flag; iter->tr = tr;
mutex_lock(&ops->func_hash->regex_lock);
if (flag & FTRACE_ITER_NOTRACE) { hash = ops->func_hash->notrace_hash; mod_head = tr ? &tr->mod_notrace : NULL; } else { hash = ops->func_hash->filter_hash; mod_head = tr ? &tr->mod_trace : NULL; }
iter->mod_list = mod_head;
if (file->f_mode & FMODE_WRITE) { const int size_bits = FTRACE_HASH_DEFAULT_BITS;
if (file->f_flags & O_TRUNC) { iter->hash = alloc_ftrace_hash(size_bits); clear_ftrace_mod_list(mod_head); } else { iter->hash = alloc_and_copy_ftrace_hash(size_bits, hash); } } else { if (hash) iter->hash = alloc_and_copy_ftrace_hash(hash->size_bits, hash); else iter->hash = EMPTY_HASH; }
if (!iter->hash) { trace_parser_put(&iter->parser); goto out_unlock; }
ret = 0;
if (file->f_mode & FMODE_READ) { iter->pg = ftrace_pages_start;
ret = seq_open(file, &show_ftrace_seq_ops); if (!ret) { struct seq_file *m = file->private_data; m->private = iter; } else { /* Failed */ free_ftrace_hash(iter->hash); trace_parser_put(&iter->parser); } } else file->private_data = iter;
out_unlock: mutex_unlock(&ops->func_hash->regex_lock);
out: if (ret) { kfree(iter); if (tr) trace_array_put(tr); }
return ret;}
static intftrace_filter_open(struct inode *inode, struct file *file){ struct ftrace_ops *ops = inode->i_private;
/* Checks for tracefs lockdown */ return ftrace_regex_open(ops, FTRACE_ITER_FILTER | FTRACE_ITER_DO_PROBES, inode, file);}
static intftrace_notrace_open(struct inode *inode, struct file *file){ struct ftrace_ops *ops = inode->i_private;
/* Checks for tracefs lockdown */ return ftrace_regex_open(ops, FTRACE_ITER_NOTRACE, inode, file);}
/* Type for quick search ftrace basic regexes (globs) from filter_parse_regex */struct ftrace_glob { char *search; unsigned len; int type;};
/* * If symbols in an architecture don't correspond exactly to the user-visible * name of what they represent, it is possible to define this function to * perform the necessary adjustments.*/char * __weak arch_ftrace_match_adjust(char *str, const char *search){ return str;}
static int ftrace_match(char *str, struct ftrace_glob *g){ int matched = 0; int slen;
str = arch_ftrace_match_adjust(str, g->search);
switch (g->type) { case MATCH_FULL: if (strcmp(str, g->search) == 0) matched = 1; break; case MATCH_FRONT_ONLY: if (strncmp(str, g->search, g->len) == 0) matched = 1; break; case MATCH_MIDDLE_ONLY: if (strstr(str, g->search)) matched = 1; break; case MATCH_END_ONLY: slen = strlen(str); if (slen >= g->len && memcmp(str + slen - g->len, g->search, g->len) == 0) matched = 1; break; case MATCH_GLOB: if (glob_match(g->search, str)) matched = 1; break; }
return matched;}
static intenter_record(struct ftrace_hash *hash, struct dyn_ftrace *rec, int clear_filter){ struct ftrace_func_entry *entry; int ret = 0;
entry = ftrace_lookup_ip(hash, rec->ip); if (clear_filter) { /* Do nothing if it doesn't exist */ if (!entry) return 0;
free_hash_entry(hash, entry); } else { /* Do nothing if it exists */ if (entry) return 0; if (add_hash_entry(hash, rec->ip) == NULL) ret = -ENOMEM; } return ret;}
static intadd_rec_by_index(struct ftrace_hash *hash, struct ftrace_glob *func_g, int clear_filter){ long index; struct ftrace_page *pg; struct dyn_ftrace *rec;
/* The index starts at 1 */ if (kstrtoul(func_g->search, 0, &index) || --index < 0) return 0;
do_for_each_ftrace_rec(pg, rec) { if (pg->index <= index) { index -= pg->index; /* this is a double loop, break goes to the next page */ break; } rec = &pg->records[index]; enter_record(hash, rec, clear_filter); return 1; } while_for_each_ftrace_rec(); return 0;}
#ifdef FTRACE_MCOUNT_MAX_OFFSETstatic int lookup_ip(unsigned long ip, char **modname, char *str){ unsigned long offset;
kallsyms_lookup(ip, NULL, &offset, modname, str); if (offset > FTRACE_MCOUNT_MAX_OFFSET) return -1; return 0;}#elsestatic int lookup_ip(unsigned long ip, char **modname, char *str){ kallsyms_lookup(ip, NULL, NULL, modname, str); return 0;}#endif
static intftrace_match_record(struct dyn_ftrace *rec, struct ftrace_glob *func_g, struct ftrace_glob *mod_g, int exclude_mod){ char str[KSYM_SYMBOL_LEN]; char *modname;
if (lookup_ip(rec->ip, &modname, str)) { /* This should only happen when a rec is disabled */ WARN_ON_ONCE(system_state == SYSTEM_RUNNING && !(rec->flags & FTRACE_FL_DISABLED)); return 0; }
if (mod_g) { int mod_matches = (modname) ? ftrace_match(modname, mod_g) : 0;
/* blank module name to match all modules */ if (!mod_g->len) { /* blank module globbing: modname xor exclude_mod */ if (!exclude_mod != !modname) goto func_match; return 0; }
/* * exclude_mod is set to trace everything but the given * module. If it is set and the module matches, then * return 0. If it is not set, and the module doesn't match * also return 0. Otherwise, check the function to see if * that matches. */ if (!mod_matches == !exclude_mod) return 0;func_match: /* blank search means to match all funcs in the mod */ if (!func_g->len) return 1; }
return ftrace_match(str, func_g);}
static intmatch_records(struct ftrace_hash *hash, char *func, int len, char *mod){ struct ftrace_page *pg; struct dyn_ftrace *rec; struct ftrace_glob func_g = { .type = MATCH_FULL }; struct ftrace_glob mod_g = { .type = MATCH_FULL }; struct ftrace_glob *mod_match = (mod) ? &mod_g : NULL; int exclude_mod = 0; int found = 0; int ret; int clear_filter = 0;
if (func) { func_g.type = filter_parse_regex(func, len, &func_g.search, &clear_filter); func_g.len = strlen(func_g.search); }
if (mod) { mod_g.type = filter_parse_regex(mod, strlen(mod), &mod_g.search, &exclude_mod); mod_g.len = strlen(mod_g.search); }
guard(mutex)(&ftrace_lock);
if (unlikely(ftrace_disabled)) return 0;
if (func_g.type == MATCH_INDEX) return add_rec_by_index(hash, &func_g, clear_filter);
do_for_each_ftrace_rec(pg, rec) {
if (rec->flags & FTRACE_FL_DISABLED) continue;
if (ftrace_match_record(rec, &func_g, mod_match, exclude_mod)) { ret = enter_record(hash, rec, clear_filter); if (ret < 0) return ret; found = 1; } cond_resched(); } while_for_each_ftrace_rec();
return found;}
static intftrace_match_records(struct ftrace_hash *hash, char *buff, int len){ return match_records(hash, buff, len, NULL);}
static void ftrace_ops_update_code(struct ftrace_ops *ops, struct ftrace_ops_hash *old_hash){ struct ftrace_ops *op;
if (!ftrace_enabled) return;
if (ops->flags & FTRACE_OPS_FL_ENABLED) { ftrace_run_modify_code(ops, FTRACE_UPDATE_CALLS, old_hash); return; }
/* * If this is the shared global_ops filter, then we need to * check if there is another ops that shares it, is enabled. * If so, we still need to run the modify code. */ if (ops->func_hash != &global_ops.local_hash) return;
do_for_each_ftrace_op(op, ftrace_ops_list) { if (op->func_hash == &global_ops.local_hash && op->flags & FTRACE_OPS_FL_ENABLED) { ftrace_run_modify_code(op, FTRACE_UPDATE_CALLS, old_hash); /* Only need to do this once */ return; } } while_for_each_ftrace_op(op);}
static int ftrace_hash_move_and_update_ops(struct ftrace_ops *ops, struct ftrace_hash **orig_hash, struct ftrace_hash *hash, int enable){ if (ops->flags & FTRACE_OPS_FL_SUBOP) return ftrace_hash_move_and_update_subops(ops, orig_hash, hash);
/* * If this ops is not enabled, it could be sharing its filters * with a subop. If that's the case, update the subop instead of * this ops. Shared filters are only allowed to have one ops set * at a time, and if we update the ops that is not enabled, * it will not affect subops that share it. */ if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) { struct ftrace_ops *op;
/* Check if any other manager subops maps to this hash */ do_for_each_ftrace_op(op, ftrace_ops_list) { struct ftrace_ops *subops;
list_for_each_entry(subops, &op->subop_list, list) { if ((subops->flags & FTRACE_OPS_FL_ENABLED) && subops->func_hash == ops->func_hash) { return ftrace_hash_move_and_update_subops(subops, orig_hash, hash); } } } while_for_each_ftrace_op(op); }
return __ftrace_hash_move_and_update_ops(ops, orig_hash, hash, enable);}
static int cache_mod(struct trace_array *tr, const char *func, char *module, int enable){ struct ftrace_mod_load *ftrace_mod, *n; struct list_head *head = enable ? &tr->mod_trace : &tr->mod_notrace;
guard(mutex)(&ftrace_lock);
/* We do not cache inverse filters */ if (func[0] == '!') { int ret = -EINVAL;
func++;
/* Look to remove this hash */ list_for_each_entry_safe(ftrace_mod, n, head, list) { if (strcmp(ftrace_mod->module, module) != 0) continue;
/* no func matches all */ if (strcmp(func, "*") == 0 || (ftrace_mod->func && strcmp(ftrace_mod->func, func) == 0)) { ret = 0; free_ftrace_mod(ftrace_mod); continue; } } return ret; }
/* We only care about modules that have not been loaded yet */ if (module_exists(module)) return -EINVAL;
/* Save this string off, and execute it when the module is loaded */ return ftrace_add_mod(tr, func, module, enable);}
#ifdef CONFIG_MODULESstatic void process_mod_list(struct list_head *head, struct ftrace_ops *ops, char *mod, bool enable){ struct ftrace_mod_load *ftrace_mod, *n; struct ftrace_hash **orig_hash, *new_hash; LIST_HEAD(process_mods); char *func;
mutex_lock(&ops->func_hash->regex_lock);
if (enable) orig_hash = &ops->func_hash->filter_hash; else orig_hash = &ops->func_hash->notrace_hash;
new_hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash); if (!new_hash) goto out; /* warn? */
mutex_lock(&ftrace_lock);
list_for_each_entry_safe(ftrace_mod, n, head, list) {
if (strcmp(ftrace_mod->module, mod) != 0) continue;
if (ftrace_mod->func) func = kstrdup(ftrace_mod->func, GFP_KERNEL); else func = kstrdup("*", GFP_KERNEL);
if (!func) /* warn? */ continue;
list_move(&ftrace_mod->list, &process_mods);
/* Use the newly allocated func, as it may be "*" */ kfree(ftrace_mod->func); ftrace_mod->func = func; }
mutex_unlock(&ftrace_lock);
list_for_each_entry_safe(ftrace_mod, n, &process_mods, list) {
func = ftrace_mod->func;
/* Grabs ftrace_lock, which is why we have this extra step */ match_records(new_hash, func, strlen(func), mod); free_ftrace_mod(ftrace_mod); }
if (enable && list_empty(head)) new_hash->flags &= ~FTRACE_HASH_FL_MOD;
mutex_lock(&ftrace_lock);
ftrace_hash_move_and_update_ops(ops, orig_hash, new_hash, enable); mutex_unlock(&ftrace_lock);
out: mutex_unlock(&ops->func_hash->regex_lock);
free_ftrace_hash(new_hash);}
static void process_cached_mods(const char *mod_name){ struct trace_array *tr; char *mod;
mod = kstrdup(mod_name, GFP_KERNEL); if (!mod) return;
mutex_lock(&trace_types_lock); list_for_each_entry(tr, &ftrace_trace_arrays, list) { if (!list_empty(&tr->mod_trace)) process_mod_list(&tr->mod_trace, tr->ops, mod, true); if (!list_empty(&tr->mod_notrace)) process_mod_list(&tr->mod_notrace, tr->ops, mod, false); } mutex_unlock(&trace_types_lock);
kfree(mod);}#endif
/* * We register the module command as a template to show others how * to register the a command as well. */
static intftrace_mod_callback(struct trace_array *tr, struct ftrace_hash *hash, char *func_orig, char *cmd, char *module, int enable){ char *func; int ret;
if (!tr) return -ENODEV;
/* match_records() modifies func, and we need the original */ func = kstrdup(func_orig, GFP_KERNEL); if (!func) return -ENOMEM;
/* * cmd == 'mod' because we only registered this func * for the 'mod' ftrace_func_command. * But if you register one func with multiple commands, * you can tell which command was used by the cmd * parameter. */ ret = match_records(hash, func, strlen(func), module); kfree(func);
if (!ret) return cache_mod(tr, func_orig, module, enable); if (ret < 0) return ret; return 0;}
static struct ftrace_func_command ftrace_mod_cmd = { .name = "mod", .func = ftrace_mod_callback,};
static int __init ftrace_mod_cmd_init(void){ return register_ftrace_command(&ftrace_mod_cmd);}core_initcall(ftrace_mod_cmd_init);
static void function_trace_probe_call(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct ftrace_regs *fregs){ struct ftrace_probe_ops *probe_ops; struct ftrace_func_probe *probe;
probe = container_of(op, struct ftrace_func_probe, ops); probe_ops = probe->probe_ops;
/* * Disable preemption for these calls to prevent a RCU grace * period. This syncs the hash iteration and freeing of items * on the hash. rcu_read_lock is too dangerous here. */ preempt_disable_notrace(); probe_ops->func(ip, parent_ip, probe->tr, probe_ops, probe->data); preempt_enable_notrace();}
struct ftrace_func_map { struct ftrace_func_entry entry; void *data;};
/* * Note, ftrace_func_mapper is freed by free_ftrace_hash(&mapper->hash). * The hash field must be the first field. */struct ftrace_func_mapper { struct ftrace_hash hash; /* Must be first! */};
/** * allocate_ftrace_func_mapper - allocate a new ftrace_func_mapper * * Returns: a ftrace_func_mapper descriptor that can be used to map ips to data. */struct ftrace_func_mapper *allocate_ftrace_func_mapper(void){ struct ftrace_hash *hash;
/* * The mapper is simply a ftrace_hash, but since the entries * in the hash are not ftrace_func_entry type, we define it * as a separate structure. */ hash = alloc_ftrace_hash(FTRACE_HASH_DEFAULT_BITS); return (struct ftrace_func_mapper *)hash;}
/** * ftrace_func_mapper_find_ip - Find some data mapped to an ip * @mapper: The mapper that has the ip maps * @ip: the instruction pointer to find the data for * * Returns: the data mapped to @ip if found otherwise NULL. The return * is actually the address of the mapper data pointer. The address is * returned for use cases where the data is no bigger than a long, and * the user can use the data pointer as its data instead of having to * allocate more memory for the reference. */void **ftrace_func_mapper_find_ip(struct ftrace_func_mapper *mapper, unsigned long ip){ struct ftrace_func_entry *entry; struct ftrace_func_map *map;
entry = ftrace_lookup_ip(&mapper->hash, ip); if (!entry) return NULL;
map = (struct ftrace_func_map *)entry; return &map->data;}
/** * ftrace_func_mapper_add_ip - Map some data to an ip * @mapper: The mapper that has the ip maps * @ip: The instruction pointer address to map @data to * @data: The data to map to @ip * * Returns: 0 on success otherwise an error. */int ftrace_func_mapper_add_ip(struct ftrace_func_mapper *mapper, unsigned long ip, void *data){ struct ftrace_func_entry *entry; struct ftrace_func_map *map;
entry = ftrace_lookup_ip(&mapper->hash, ip); if (entry) return -EBUSY;
map = kmalloc_obj(*map); if (!map) return -ENOMEM;
map->entry.ip = ip; map->data = data;
add_ftrace_hash_entry(&mapper->hash, &map->entry);
return 0;}
/** * ftrace_func_mapper_remove_ip - Remove an ip from the mapping * @mapper: The mapper that has the ip maps * @ip: The instruction pointer address to remove the data from * * Returns: the data if it is found, otherwise NULL. * Note, if the data pointer is used as the data itself, (see * ftrace_func_mapper_find_ip(), then the return value may be meaningless, * if the data pointer was set to zero. */void *ftrace_func_mapper_remove_ip(struct ftrace_func_mapper *mapper, unsigned long ip){ struct ftrace_func_entry *entry; struct ftrace_func_map *map; void *data;
entry = ftrace_lookup_ip(&mapper->hash, ip); if (!entry) return NULL;
map = (struct ftrace_func_map *)entry; data = map->data;
remove_hash_entry(&mapper->hash, entry); kfree(entry);
return data;}
/** * free_ftrace_func_mapper - free a mapping of ips and data * @mapper: The mapper that has the ip maps * @free_func: A function to be called on each data item. * * This is used to free the function mapper. The @free_func is optional * and can be used if the data needs to be freed as well. */void free_ftrace_func_mapper(struct ftrace_func_mapper *mapper, ftrace_mapper_func free_func){ struct ftrace_func_entry *entry; struct ftrace_func_map *map; struct hlist_head *hhd; int size, i;
if (!mapper) return;
if (free_func && mapper->hash.count) { size = 1 << mapper->hash.size_bits; for (i = 0; i < size; i++) { hhd = &mapper->hash.buckets[i]; hlist_for_each_entry(entry, hhd, hlist) { map = (struct ftrace_func_map *)entry; free_func(map); } } } /* This also frees the mapper itself */ free_ftrace_hash(&mapper->hash);}
static void release_probe(struct ftrace_func_probe *probe){ struct ftrace_probe_ops *probe_ops;
guard(mutex)(&ftrace_lock);
WARN_ON(probe->ref <= 0);
/* Subtract the ref that was used to protect this instance */ probe->ref--;
if (!probe->ref) { probe_ops = probe->probe_ops; /* * Sending zero as ip tells probe_ops to free * the probe->data itself */ if (probe_ops->free) probe_ops->free(probe_ops, probe->tr, 0, probe->data); list_del(&probe->list); kfree(probe); }}
static void acquire_probe_locked(struct ftrace_func_probe *probe){ /* * Add one ref to keep it from being freed when releasing the * ftrace_lock mutex. */ probe->ref++;}
intregister_ftrace_function_probe(char *glob, struct trace_array *tr, struct ftrace_probe_ops *probe_ops, void *data){ struct ftrace_func_probe *probe = NULL, *iter; struct ftrace_func_entry *entry; struct ftrace_hash **orig_hash; struct ftrace_hash *old_hash; struct ftrace_hash *hash; int count = 0; int size; int ret; int i;
if (WARN_ON(!tr)) return -EINVAL;
/* We do not support '!' for function probes */ if (WARN_ON(glob[0] == '!')) return -EINVAL;
mutex_lock(&ftrace_lock); /* Check if the probe_ops is already registered */ list_for_each_entry(iter, &tr->func_probes, list) { if (iter->probe_ops == probe_ops) { probe = iter; break; } } if (!probe) { probe = kzalloc_obj(*probe); if (!probe) { mutex_unlock(&ftrace_lock); return -ENOMEM; } probe->probe_ops = probe_ops; probe->ops.func = function_trace_probe_call; probe->tr = tr; ftrace_ops_init(&probe->ops); list_add(&probe->list, &tr->func_probes); }
acquire_probe_locked(probe);
mutex_unlock(&ftrace_lock);
/* * Note, there's a small window here that the func_hash->filter_hash * may be NULL or empty. Need to be careful when reading the loop. */ mutex_lock(&probe->ops.func_hash->regex_lock);
orig_hash = &probe->ops.func_hash->filter_hash; old_hash = *orig_hash; hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, old_hash);
if (!hash) { ret = -ENOMEM; goto out; }
ret = ftrace_match_records(hash, glob, strlen(glob));
/* Nothing found? */ if (!ret) ret = -EINVAL;
if (ret < 0) goto out;
size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &hash->buckets[i], hlist) { if (ftrace_lookup_ip(old_hash, entry->ip)) continue; /* * The caller might want to do something special * for each function we find. We call the callback * to give the caller an opportunity to do so. */ if (probe_ops->init) { ret = probe_ops->init(probe_ops, tr, entry->ip, data, &probe->data); if (ret < 0) { if (probe_ops->free && count) probe_ops->free(probe_ops, tr, 0, probe->data); probe->data = NULL; goto out; } } count++; } }
mutex_lock(&ftrace_lock);
if (!count) { /* Nothing was added? */ ret = -EINVAL; goto out_unlock; }
ret = ftrace_hash_move_and_update_ops(&probe->ops, orig_hash, hash, 1); if (ret < 0) goto err_unlock;
/* One ref for each new function traced */ probe->ref += count;
if (!(probe->ops.flags & FTRACE_OPS_FL_ENABLED)) ret = ftrace_startup(&probe->ops, 0);
out_unlock: mutex_unlock(&ftrace_lock);
if (!ret) ret = count; out: mutex_unlock(&probe->ops.func_hash->regex_lock); free_ftrace_hash(hash);
release_probe(probe);
return ret;
err_unlock: if (!probe_ops->free || !count) goto out_unlock;
/* Failed to do the move, need to call the free functions */ for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &hash->buckets[i], hlist) { if (ftrace_lookup_ip(old_hash, entry->ip)) continue; probe_ops->free(probe_ops, tr, entry->ip, probe->data); } } goto out_unlock;}
intunregister_ftrace_function_probe_func(char *glob, struct trace_array *tr, struct ftrace_probe_ops *probe_ops){ struct ftrace_func_probe *probe = NULL, *iter; struct ftrace_ops_hash old_hash_ops; struct ftrace_func_entry *entry; struct ftrace_glob func_g; struct ftrace_hash **orig_hash; struct ftrace_hash *old_hash; struct ftrace_hash *hash = NULL; struct hlist_node *tmp; struct hlist_head hhd; char str[KSYM_SYMBOL_LEN]; int count = 0; int i, ret = -ENODEV; int size;
if (!glob || !strlen(glob) || !strcmp(glob, "*")) func_g.search = NULL; else { int not;
func_g.type = filter_parse_regex(glob, strlen(glob), &func_g.search, ¬); func_g.len = strlen(func_g.search);
/* we do not support '!' for function probes */ if (WARN_ON(not)) return -EINVAL; }
mutex_lock(&ftrace_lock); /* Check if the probe_ops is already registered */ list_for_each_entry(iter, &tr->func_probes, list) { if (iter->probe_ops == probe_ops) { probe = iter; break; } } if (!probe) goto err_unlock_ftrace;
ret = -EINVAL; if (!(probe->ops.flags & FTRACE_OPS_FL_INITIALIZED)) goto err_unlock_ftrace;
acquire_probe_locked(probe);
mutex_unlock(&ftrace_lock);
mutex_lock(&probe->ops.func_hash->regex_lock);
orig_hash = &probe->ops.func_hash->filter_hash; old_hash = *orig_hash;
if (ftrace_hash_empty(old_hash)) goto out_unlock;
old_hash_ops.filter_hash = old_hash; /* Probes only have filters */ old_hash_ops.notrace_hash = NULL;
ret = -ENOMEM; hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, old_hash); if (!hash) goto out_unlock;
INIT_HLIST_HEAD(&hhd);
size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry_safe(entry, tmp, &hash->buckets[i], hlist) {
if (func_g.search) { kallsyms_lookup(entry->ip, NULL, NULL, NULL, str); if (!ftrace_match(str, &func_g)) continue; } count++; remove_hash_entry(hash, entry); hlist_add_head(&entry->hlist, &hhd); } }
/* Nothing found? */ if (!count) { ret = -EINVAL; goto out_unlock; }
mutex_lock(&ftrace_lock);
WARN_ON(probe->ref < count);
probe->ref -= count;
if (ftrace_hash_empty(hash)) ftrace_shutdown(&probe->ops, 0);
ret = ftrace_hash_move_and_update_ops(&probe->ops, orig_hash, hash, 1);
/* still need to update the function call sites */ if (ftrace_enabled && !ftrace_hash_empty(hash)) ftrace_run_modify_code(&probe->ops, FTRACE_UPDATE_CALLS, &old_hash_ops); synchronize_rcu();
hlist_for_each_entry_safe(entry, tmp, &hhd, hlist) { hlist_del(&entry->hlist); if (probe_ops->free) probe_ops->free(probe_ops, tr, entry->ip, probe->data); kfree(entry); } mutex_unlock(&ftrace_lock);
out_unlock: mutex_unlock(&probe->ops.func_hash->regex_lock); free_ftrace_hash(hash);
release_probe(probe);
return ret;
err_unlock_ftrace: mutex_unlock(&ftrace_lock); return ret;}
void clear_ftrace_function_probes(struct trace_array *tr){ struct ftrace_func_probe *probe, *n;
list_for_each_entry_safe(probe, n, &tr->func_probes, list) unregister_ftrace_function_probe_func(NULL, tr, probe->probe_ops);}
static LIST_HEAD(ftrace_commands);static DEFINE_MUTEX(ftrace_cmd_mutex);
/* * Currently we only register ftrace commands from __init, so mark this * __init too. */__init int register_ftrace_command(struct ftrace_func_command *cmd){ struct ftrace_func_command *p;
guard(mutex)(&ftrace_cmd_mutex); list_for_each_entry(p, &ftrace_commands, list) { if (strcmp(cmd->name, p->name) == 0) return -EBUSY; } list_add(&cmd->list, &ftrace_commands);
return 0;}
/* * Currently we only unregister ftrace commands from __init, so mark * this __init too. */__init int unregister_ftrace_command(struct ftrace_func_command *cmd){ struct ftrace_func_command *p, *n;
guard(mutex)(&ftrace_cmd_mutex);
list_for_each_entry_safe(p, n, &ftrace_commands, list) { if (strcmp(cmd->name, p->name) == 0) { list_del_init(&p->list); return 0; } }
return -ENODEV;}
static int ftrace_process_regex(struct ftrace_iterator *iter, char *buff, int len, int enable){ struct ftrace_hash *hash = iter->hash; struct trace_array *tr = iter->ops->private; char *func, *command, *next = buff; struct ftrace_func_command *p; int ret;
func = strsep(&next, ":");
if (!next) { ret = ftrace_match_records(hash, func, len); if (!ret) ret = -EINVAL; if (ret < 0) return ret; return 0; }
/* command found */
command = strsep(&next, ":");
guard(mutex)(&ftrace_cmd_mutex);
list_for_each_entry(p, &ftrace_commands, list) { if (strcmp(p->name, command) == 0) return p->func(tr, hash, func, command, next, enable); }
return -EINVAL;}
static ssize_tftrace_regex_write(struct file *file, const char __user *ubuf, size_t cnt, loff_t *ppos, int enable){ struct ftrace_iterator *iter; struct trace_parser *parser; ssize_t ret, read;
if (!cnt) return 0;
if (file->f_mode & FMODE_READ) { struct seq_file *m = file->private_data; iter = m->private; } else iter = file->private_data;
if (unlikely(ftrace_disabled)) return -ENODEV;
/* iter->hash is a local copy, so we don't need regex_lock */
parser = &iter->parser;
guard(mutex)(&parser_lock); read = trace_get_user(parser, ubuf, cnt, ppos);
if (read >= 0 && trace_parser_loaded(parser) && !trace_parser_cont(parser)) { ret = ftrace_process_regex(iter, parser->buffer, parser->idx, enable); trace_parser_clear(parser); if (ret < 0) return ret; }
return read;}
ssize_tftrace_filter_write(struct file *file, const char __user *ubuf, size_t cnt, loff_t *ppos){ return ftrace_regex_write(file, ubuf, cnt, ppos, 1);}
ssize_tftrace_notrace_write(struct file *file, const char __user *ubuf, size_t cnt, loff_t *ppos){ return ftrace_regex_write(file, ubuf, cnt, ppos, 0);}
static int__ftrace_match_addr(struct ftrace_hash *hash, unsigned long ip, int remove){ struct ftrace_func_entry *entry;
ip = ftrace_location(ip); if (!ip) return -EINVAL;
if (remove) { entry = ftrace_lookup_ip(hash, ip); if (!entry) return -ENOENT; free_hash_entry(hash, entry); return 0; } else if (__ftrace_lookup_ip(hash, ip) != NULL) { /* Already exists */ return 0; }
entry = add_hash_entry(hash, ip); return entry ? 0 : -ENOMEM;}
static intftrace_match_addr(struct ftrace_hash *hash, unsigned long *ips, unsigned int cnt, int remove){ unsigned int i; int err;
for (i = 0; i < cnt; i++) { err = __ftrace_match_addr(hash, ips[i], remove); if (err) { /* * This expects the @hash is a temporary hash and if this * fails the caller must free the @hash. */ return err; } } return 0;}
static intftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len, unsigned long *ips, unsigned int cnt, int remove, int reset, int enable, char *mod){ struct ftrace_hash **orig_hash; struct ftrace_hash *hash; int ret;
if (unlikely(ftrace_disabled)) return -ENODEV;
mutex_lock(&ops->func_hash->regex_lock);
if (enable) orig_hash = &ops->func_hash->filter_hash; else orig_hash = &ops->func_hash->notrace_hash;
if (reset) hash = alloc_ftrace_hash(FTRACE_HASH_DEFAULT_BITS); else hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS, *orig_hash);
if (!hash) { ret = -ENOMEM; goto out_regex_unlock; }
if (buf && !match_records(hash, buf, len, mod)) { /* If this was for a module and nothing was enabled, flag it */ if (mod) (*orig_hash)->flags |= FTRACE_HASH_FL_MOD;
/* * Even if it is a mod, return error to let caller know * nothing was added */ ret = -EINVAL; goto out_regex_unlock; } if (ips) { ret = ftrace_match_addr(hash, ips, cnt, remove); if (ret < 0) goto out_regex_unlock; }
mutex_lock(&ftrace_lock); ret = ftrace_hash_move_and_update_ops(ops, orig_hash, hash, enable); mutex_unlock(&ftrace_lock);
out_regex_unlock: mutex_unlock(&ops->func_hash->regex_lock);
free_ftrace_hash(hash); return ret;}
static intftrace_set_addr(struct ftrace_ops *ops, unsigned long *ips, unsigned int cnt, int remove, int reset, int enable){ return ftrace_set_hash(ops, NULL, 0, ips, cnt, remove, reset, enable, NULL);}
#ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
static int register_ftrace_function_nolock(struct ftrace_ops *ops);
/* * If there are multiple ftrace_ops, use SAVE_REGS by default, so that direct * call will be jumped from ftrace_regs_caller. Only if the architecture does * not support ftrace_regs_caller but direct_call, use SAVE_ARGS so that it * jumps from ftrace_caller for multiple ftrace_ops. */#ifndef CONFIG_HAVE_DYNAMIC_FTRACE_WITH_REGS#define MULTI_FLAGS (FTRACE_OPS_FL_DIRECT | FTRACE_OPS_FL_SAVE_ARGS)#else#define MULTI_FLAGS (FTRACE_OPS_FL_DIRECT | FTRACE_OPS_FL_SAVE_REGS)#endif
static int check_direct_multi(struct ftrace_ops *ops){ if (!(ops->flags & FTRACE_OPS_FL_INITIALIZED)) return -EINVAL; if ((ops->flags & MULTI_FLAGS) != MULTI_FLAGS) return -EINVAL; return 0;}
static void remove_direct_functions_hash(struct ftrace_hash *hash, unsigned long addr){ struct ftrace_func_entry *entry, *del; int size, i;
size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &hash->buckets[i], hlist) { del = __ftrace_lookup_ip(direct_functions, entry->ip); if (del && ftrace_jmp_get(del->direct) == ftrace_jmp_get(addr)) { remove_hash_entry(direct_functions, del); kfree(del); } } }}
static void register_ftrace_direct_cb(struct rcu_head *rhp){ struct ftrace_hash *fhp = container_of(rhp, struct ftrace_hash, rcu);
free_ftrace_hash(fhp);}
static void reset_direct(struct ftrace_ops *ops, unsigned long addr){ struct ftrace_hash *hash = ops->func_hash->filter_hash;
remove_direct_functions_hash(hash, addr);
/* cleanup for possible another register call */ ops->func = NULL; ops->trampoline = 0;}
/** * register_ftrace_direct - Call a custom trampoline directly * for multiple functions registered in @ops * @ops: The address of the struct ftrace_ops object * @addr: The address of the trampoline to call at @ops functions * * This is used to connect a direct calls to @addr from the nop locations * of the functions registered in @ops (with by ftrace_set_filter_ip * function). * * The location that it calls (@addr) must be able to handle a direct call, * and save the parameters of the function being traced, and restore them * (or inject new ones if needed), before returning. * * Returns: * 0 on success * -EINVAL - The @ops object was already registered with this call or * when there are no functions in @ops object. * -EBUSY - Another direct function is already attached (there can be only one) * -ENODEV - @ip does not point to a ftrace nop location (or not supported) * -ENOMEM - There was an allocation failure. */int register_ftrace_direct(struct ftrace_ops *ops, unsigned long addr){ struct ftrace_hash *hash, *new_hash = NULL, *free_hash = NULL; struct ftrace_func_entry *entry, *new; int err = -EBUSY, size, i;
if (ops->func || ops->trampoline) return -EINVAL; if (!(ops->flags & FTRACE_OPS_FL_INITIALIZED)) return -EINVAL; if (ops->flags & FTRACE_OPS_FL_ENABLED) return -EINVAL;
hash = ops->func_hash->filter_hash; if (ftrace_hash_empty(hash)) return -EINVAL;
mutex_lock(&direct_mutex);
/* Make sure requested entries are not already registered.. */ size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &hash->buckets[i], hlist) { if (ftrace_find_rec_direct(entry->ip)) goto out_unlock; } }
err = -ENOMEM;
/* Make a copy hash to place the new and the old entries in */ size = hash->count + direct_functions->count; size = fls(size); if (size > FTRACE_HASH_MAX_BITS) size = FTRACE_HASH_MAX_BITS; new_hash = alloc_ftrace_hash(size); if (!new_hash) goto out_unlock;
/* Now copy over the existing direct entries */ size = 1 << direct_functions->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &direct_functions->buckets[i], hlist) { new = add_hash_entry(new_hash, entry->ip); if (!new) goto out_unlock; new->direct = entry->direct; } }
/* ... and add the new entries */ size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &hash->buckets[i], hlist) { new = add_hash_entry(new_hash, entry->ip); if (!new) goto out_unlock; /* Update both the copy and the hash entry */ new->direct = addr; entry->direct = addr; } }
free_hash = direct_functions; rcu_assign_pointer(direct_functions, new_hash); new_hash = NULL;
ops->func = call_direct_funcs; ops->flags |= MULTI_FLAGS; ops->trampoline = FTRACE_REGS_ADDR; ops->direct_call = addr;
err = register_ftrace_function_nolock(ops); if (err) reset_direct(ops, addr);
out_unlock: mutex_unlock(&direct_mutex);
if (free_hash && free_hash != EMPTY_HASH) call_rcu_tasks(&free_hash->rcu, register_ftrace_direct_cb);
if (new_hash) free_ftrace_hash(new_hash);
return err;}EXPORT_SYMBOL_GPL(register_ftrace_direct);
/** * unregister_ftrace_direct - Remove calls to custom trampoline * previously registered by register_ftrace_direct for @ops object. * @ops: The address of the struct ftrace_ops object * @addr: The address of the direct function that is called by the @ops functions * @free_filters: Set to true to remove all filters for the ftrace_ops, false otherwise * * This is used to remove a direct calls to @addr from the nop locations * of the functions registered in @ops (with by ftrace_set_filter_ip * function). * * Returns: * 0 on success * -EINVAL - The @ops object was not properly registered. */int unregister_ftrace_direct(struct ftrace_ops *ops, unsigned long addr, bool free_filters){ int err;
if (check_direct_multi(ops)) return -EINVAL; if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) return -EINVAL;
mutex_lock(&direct_mutex); err = unregister_ftrace_function(ops); reset_direct(ops, addr); mutex_unlock(&direct_mutex);
if (free_filters) ftrace_free_filter(ops); return err;}EXPORT_SYMBOL_GPL(unregister_ftrace_direct);
static int__modify_ftrace_direct(struct ftrace_ops *ops, unsigned long addr){ struct ftrace_hash *hash = ops->func_hash->filter_hash; struct ftrace_func_entry *entry, *iter; static struct ftrace_ops tmp_ops = { .func = ftrace_stub, .flags = FTRACE_OPS_FL_STUB, }; int i, size; int err;
lockdep_assert_held_once(&direct_mutex);
/* Enable the tmp_ops to have the same functions as the direct ops */ ftrace_ops_init(&tmp_ops); tmp_ops.func_hash = ops->func_hash; tmp_ops.direct_call = addr;
err = register_ftrace_function_nolock(&tmp_ops); if (err) return err;
/* * Call __ftrace_hash_update_ipmodify() here, so that we can call * ops->ops_func for the ops. This is needed because the above * register_ftrace_function_nolock() worked on tmp_ops. */ err = __ftrace_hash_update_ipmodify(ops, hash, hash, true); if (err) goto out;
/* * Now the ftrace_ops_list_func() is called to do the direct callers. * We can safely change the direct functions attached to each entry. */ mutex_lock(&ftrace_lock);
size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(iter, &hash->buckets[i], hlist) { entry = __ftrace_lookup_ip(direct_functions, iter->ip); if (!entry) continue; entry->direct = addr; } } /* Prevent store tearing if a trampoline concurrently accesses the value */ WRITE_ONCE(ops->direct_call, addr);
mutex_unlock(&ftrace_lock);
out: /* Removing the tmp_ops will add the updated direct callers to the functions */ unregister_ftrace_function(&tmp_ops);
return err;}
/** * modify_ftrace_direct_nolock - Modify an existing direct 'multi' call * to call something else * @ops: The address of the struct ftrace_ops object * @addr: The address of the new trampoline to call at @ops functions * * This is used to unregister currently registered direct caller and * register new one @addr on functions registered in @ops object. * * Note there's window between ftrace_shutdown and ftrace_startup calls * where there will be no callbacks called. * * Caller should already have direct_mutex locked, so we don't lock * direct_mutex here. * * Returns: zero on success. Non zero on error, which includes: * -EINVAL - The @ops object was not properly registered. */int modify_ftrace_direct_nolock(struct ftrace_ops *ops, unsigned long addr){ if (check_direct_multi(ops)) return -EINVAL; if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) return -EINVAL;
return __modify_ftrace_direct(ops, addr);}EXPORT_SYMBOL_GPL(modify_ftrace_direct_nolock);
/** * modify_ftrace_direct - Modify an existing direct 'multi' call * to call something else * @ops: The address of the struct ftrace_ops object * @addr: The address of the new trampoline to call at @ops functions * * This is used to unregister currently registered direct caller and * register new one @addr on functions registered in @ops object. * * Note there's window between ftrace_shutdown and ftrace_startup calls * where there will be no callbacks called. * * Returns: zero on success. Non zero on error, which includes: * -EINVAL - The @ops object was not properly registered. */int modify_ftrace_direct(struct ftrace_ops *ops, unsigned long addr){ int err;
if (check_direct_multi(ops)) return -EINVAL; if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) return -EINVAL;
mutex_lock(&direct_mutex); err = __modify_ftrace_direct(ops, addr); mutex_unlock(&direct_mutex); return err;}EXPORT_SYMBOL_GPL(modify_ftrace_direct);
static inline unsigned long hash_count(struct ftrace_hash *hash){ return hash ? hash->count : 0;}
unsigned long ftrace_hash_count(struct ftrace_hash *hash){ return hash_count(hash);}
/** * hash_add - adds two struct ftrace_hash and returns the result * @a: struct ftrace_hash object * @b: struct ftrace_hash object * * Returns struct ftrace_hash object on success, NULL on error. */static struct ftrace_hash *hash_add(struct ftrace_hash *a, struct ftrace_hash *b){ struct ftrace_func_entry *entry; struct ftrace_hash *add; int size;
size = hash_count(a) + hash_count(b); if (size > 32) size = 32;
add = alloc_and_copy_ftrace_hash(fls(size), a); if (!add) return NULL;
size = 1 << b->size_bits; for (int i = 0; i < size; i++) { hlist_for_each_entry(entry, &b->buckets[i], hlist) { if (add_ftrace_hash_entry_direct(add, entry->ip, entry->direct) == NULL) { free_ftrace_hash(add); return NULL; } } } return add;}
/** * update_ftrace_direct_add - Updates @ops by adding direct * callers provided in @hash * @ops: The address of the struct ftrace_ops object * @hash: The address of the struct ftrace_hash object * * This is used to add custom direct callers (ip -> addr) to @ops, * specified in @hash. The @ops will be either registered or updated. * * Returns: zero on success. Non zero on error, which includes: * -EINVAL - The @hash is empty */int update_ftrace_direct_add(struct ftrace_ops *ops, struct ftrace_hash *hash){ struct ftrace_hash *old_direct_functions = NULL; struct ftrace_hash *new_direct_functions; struct ftrace_hash *old_filter_hash; struct ftrace_hash *new_filter_hash = NULL; struct ftrace_func_entry *entry; int err = -EINVAL; int size; bool reg;
if (!hash_count(hash)) return -EINVAL;
mutex_lock(&direct_mutex);
/* Make sure requested entries are not already registered. */ size = 1 << hash->size_bits; for (int i = 0; i < size; i++) { hlist_for_each_entry(entry, &hash->buckets[i], hlist) { if (__ftrace_lookup_ip(direct_functions, entry->ip)) goto out_unlock; } }
old_filter_hash = ops->func_hash ? ops->func_hash->filter_hash : NULL;
/* If there's nothing in filter_hash we need to register the ops. */ reg = hash_count(old_filter_hash) == 0; if (reg) { if (ops->func || ops->trampoline) goto out_unlock; if (ops->flags & FTRACE_OPS_FL_ENABLED) goto out_unlock; }
err = -ENOMEM; new_filter_hash = hash_add(old_filter_hash, hash); if (!new_filter_hash) goto out_unlock;
new_direct_functions = hash_add(direct_functions, hash); if (!new_direct_functions) goto out_unlock;
old_direct_functions = direct_functions; rcu_assign_pointer(direct_functions, new_direct_functions);
if (reg) { ops->func = call_direct_funcs; ops->flags |= MULTI_FLAGS; ops->trampoline = FTRACE_REGS_ADDR; ops->local_hash.filter_hash = new_filter_hash;
err = register_ftrace_function_nolock(ops); if (err) { /* restore old filter on error */ ops->local_hash.filter_hash = old_filter_hash;
/* cleanup for possible another register call */ ops->func = NULL; ops->trampoline = 0; } else { new_filter_hash = old_filter_hash; } } else { guard(mutex)(&ftrace_lock); err = ftrace_update_ops(ops, new_filter_hash, EMPTY_HASH); /* * new_filter_hash is dup-ed, so we need to release it anyway, * old_filter_hash either stays on error or is already released */ }
if (err) { /* reset direct_functions and free the new one */ rcu_assign_pointer(direct_functions, old_direct_functions); old_direct_functions = new_direct_functions; }
out_unlock: mutex_unlock(&direct_mutex);
if (old_direct_functions && old_direct_functions != EMPTY_HASH) call_rcu_tasks(&old_direct_functions->rcu, register_ftrace_direct_cb); free_ftrace_hash(new_filter_hash);
return err;}
/** * hash_sub - substracts @b from @a and returns the result * @a: struct ftrace_hash object * @b: struct ftrace_hash object * * Returns struct ftrace_hash object on success, NULL on error. */static struct ftrace_hash *hash_sub(struct ftrace_hash *a, struct ftrace_hash *b){ struct ftrace_func_entry *entry, *del; struct ftrace_hash *sub; int size;
sub = alloc_and_copy_ftrace_hash(a->size_bits, a); if (!sub) return NULL;
size = 1 << b->size_bits; for (int i = 0; i < size; i++) { hlist_for_each_entry(entry, &b->buckets[i], hlist) { del = __ftrace_lookup_ip(sub, entry->ip); if (WARN_ON_ONCE(!del)) { free_ftrace_hash(sub); return NULL; } remove_hash_entry(sub, del); kfree(del); } } return sub;}
/** * update_ftrace_direct_del - Updates @ops by removing its direct * callers provided in @hash * @ops: The address of the struct ftrace_ops object * @hash: The address of the struct ftrace_hash object * * This is used to delete custom direct callers (ip -> addr) in * @ops specified via @hash. The @ops will be either unregistered * updated. * * Returns: zero on success. Non zero on error, which includes: * -EINVAL - The @hash is empty * -EINVAL - The @ops is not registered */int update_ftrace_direct_del(struct ftrace_ops *ops, struct ftrace_hash *hash){ struct ftrace_hash *old_direct_functions = NULL; struct ftrace_hash *new_direct_functions; struct ftrace_hash *new_filter_hash = NULL; struct ftrace_hash *old_filter_hash; struct ftrace_func_entry *entry; struct ftrace_func_entry *del; unsigned long size; int err = -EINVAL;
if (!hash_count(hash)) return -EINVAL; if (check_direct_multi(ops)) return -EINVAL; if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) return -EINVAL; if (direct_functions == EMPTY_HASH) return -EINVAL;
mutex_lock(&direct_mutex);
old_filter_hash = ops->func_hash ? ops->func_hash->filter_hash : NULL;
if (!hash_count(old_filter_hash)) goto out_unlock;
/* Make sure requested entries are already registered. */ size = 1 << hash->size_bits; for (int i = 0; i < size; i++) { hlist_for_each_entry(entry, &hash->buckets[i], hlist) { del = __ftrace_lookup_ip(direct_functions, entry->ip); if (!del || del->direct != entry->direct) goto out_unlock; } }
err = -ENOMEM; new_filter_hash = hash_sub(old_filter_hash, hash); if (!new_filter_hash) goto out_unlock;
new_direct_functions = hash_sub(direct_functions, hash); if (!new_direct_functions) goto out_unlock;
/* If there's nothing left, we need to unregister the ops. */ if (ftrace_hash_empty(new_filter_hash)) { err = unregister_ftrace_function(ops); if (!err) { /* cleanup for possible another register call */ ops->func = NULL; ops->trampoline = 0; ftrace_free_filter(ops); ops->func_hash->filter_hash = NULL; } } else { guard(mutex)(&ftrace_lock); err = ftrace_update_ops(ops, new_filter_hash, EMPTY_HASH); /* * new_filter_hash is dup-ed, so we need to release it anyway, * old_filter_hash either stays on error or is already released */ }
if (err) { /* free the new_direct_functions */ old_direct_functions = new_direct_functions; } else { old_direct_functions = direct_functions; rcu_assign_pointer(direct_functions, new_direct_functions); }
out_unlock: mutex_unlock(&direct_mutex);
if (old_direct_functions && old_direct_functions != EMPTY_HASH) call_rcu_tasks(&old_direct_functions->rcu, register_ftrace_direct_cb); free_ftrace_hash(new_filter_hash);
return err;}
/** * update_ftrace_direct_mod - Updates @ops by modifing its direct * callers provided in @hash * @ops: The address of the struct ftrace_ops object * @hash: The address of the struct ftrace_hash object * @do_direct_lock: If true lock the direct_mutex * * This is used to modify custom direct callers (ip -> addr) in * @ops specified via @hash. * * This can be called from within ftrace ops_func callback with * direct_mutex already locked, in which case @do_direct_lock * needs to be false. * * Returns: zero on success. Non zero on error, which includes: * -EINVAL - The @hash is empty * -EINVAL - The @ops is not registered */int update_ftrace_direct_mod(struct ftrace_ops *ops, struct ftrace_hash *hash, bool do_direct_lock){ struct ftrace_func_entry *entry, *tmp; static struct ftrace_ops tmp_ops = { .func = ftrace_stub, .flags = FTRACE_OPS_FL_STUB, }; struct ftrace_hash *orig_hash; unsigned long size, i; int err = -EINVAL;
if (!hash_count(hash)) return -EINVAL; if (check_direct_multi(ops)) return -EINVAL; if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) return -EINVAL; if (direct_functions == EMPTY_HASH) return -EINVAL;
/* * We can be called from within ops_func callback with direct_mutex * already taken. */ if (do_direct_lock) mutex_lock(&direct_mutex);
orig_hash = ops->func_hash ? ops->func_hash->filter_hash : NULL; if (!orig_hash) goto unlock;
/* Enable the tmp_ops to have the same functions as the hash object. */ ftrace_ops_init(&tmp_ops); tmp_ops.func_hash->filter_hash = hash;
err = register_ftrace_function_nolock(&tmp_ops); if (err) goto unlock;
/* * Call __ftrace_hash_update_ipmodify() here, so that we can call * ops->ops_func for the ops. This is needed because the above * register_ftrace_function_nolock() worked on tmp_ops. */ err = __ftrace_hash_update_ipmodify(ops, orig_hash, orig_hash, true); if (err) goto out;
/* * Now the ftrace_ops_list_func() is called to do the direct callers. * We can safely change the direct functions attached to each entry. */ mutex_lock(&ftrace_lock);
size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &hash->buckets[i], hlist) { tmp = __ftrace_lookup_ip(direct_functions, entry->ip); if (!tmp) continue; tmp->direct = entry->direct; } }
mutex_unlock(&ftrace_lock);
out: /* Removing the tmp_ops will add the updated direct callers to the functions */ unregister_ftrace_function(&tmp_ops);
unlock: if (do_direct_lock) mutex_unlock(&direct_mutex); return err;}
#endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */
/** * ftrace_set_filter_ip - set a function to filter on in ftrace by address * @ops: the ops to set the filter with * @ip: the address to add to or remove from the filter. * @remove: non zero to remove the ip from the filter * @reset: non zero to reset all filters before applying this filter. * * Filters denote which functions should be enabled when tracing is enabled * If @ip is NULL, it fails to update filter. * * This can allocate memory which must be freed before @ops can be freed, * either by removing each filtered addr or by using * ftrace_free_filter(@ops). */int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip, int remove, int reset){ ftrace_ops_init(ops); return ftrace_set_addr(ops, &ip, 1, remove, reset, 1);}EXPORT_SYMBOL_GPL(ftrace_set_filter_ip);
/** * ftrace_set_filter_ips - set functions to filter on in ftrace by addresses * @ops: the ops to set the filter with * @ips: the array of addresses to add to or remove from the filter. * @cnt: the number of addresses in @ips * @remove: non zero to remove ips from the filter * @reset: non zero to reset all filters before applying this filter. * * Filters denote which functions should be enabled when tracing is enabled * If @ips array or any ip specified within is NULL , it fails to update filter. * * This can allocate memory which must be freed before @ops can be freed, * either by removing each filtered addr or by using * ftrace_free_filter(@ops).*/int ftrace_set_filter_ips(struct ftrace_ops *ops, unsigned long *ips, unsigned int cnt, int remove, int reset){ ftrace_ops_init(ops); return ftrace_set_addr(ops, ips, cnt, remove, reset, 1);}EXPORT_SYMBOL_GPL(ftrace_set_filter_ips);
/** * ftrace_ops_set_global_filter - setup ops to use global filters * @ops: the ops which will use the global filters * * ftrace users who need global function trace filtering should call this. * It can set the global filter only if ops were not initialized before. */void ftrace_ops_set_global_filter(struct ftrace_ops *ops){ if (ops->flags & FTRACE_OPS_FL_INITIALIZED) return;
ftrace_ops_init(ops); ops->func_hash = &global_ops.local_hash;}EXPORT_SYMBOL_GPL(ftrace_ops_set_global_filter);
static intftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len, int reset, int enable){ char *mod = NULL, *func, *command, *next = buf; char *tmp __free(kfree) = NULL; struct trace_array *tr = ops->private; int ret;
func = strsep(&next, ":");
/* This can also handle :mod: parsing */ if (next) { if (!tr) return -EINVAL;
command = strsep(&next, ":"); if (strcmp(command, "mod") != 0) return -EINVAL;
mod = next; len = command - func; /* Save the original func as ftrace_set_hash() can modify it */ tmp = kstrdup(func, GFP_KERNEL); }
ret = ftrace_set_hash(ops, func, len, NULL, 0, 0, reset, enable, mod);
if (tr && mod && ret < 0) { /* Did tmp fail to allocate? */ if (!tmp) return -ENOMEM; ret = cache_mod(tr, tmp, mod, enable); }
return ret;}
/** * ftrace_set_filter - set a function to filter on in ftrace * @ops: the ops to set the filter with * @buf: the string that holds the function filter text. * @len: the length of the string. * @reset: non-zero to reset all filters before applying this filter. * * Filters denote which functions should be enabled when tracing is enabled. * If @buf is NULL and reset is set, all functions will be enabled for tracing. * * This can allocate memory which must be freed before @ops can be freed, * either by removing each filtered addr or by using * ftrace_free_filter(@ops). */int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf, int len, int reset){ ftrace_ops_init(ops); return ftrace_set_regex(ops, buf, len, reset, 1);}EXPORT_SYMBOL_GPL(ftrace_set_filter);
/** * ftrace_set_notrace - set a function to not trace in ftrace * @ops: the ops to set the notrace filter with * @buf: the string that holds the function notrace text. * @len: the length of the string. * @reset: non-zero to reset all filters before applying this filter. * * Notrace Filters denote which functions should not be enabled when tracing * is enabled. If @buf is NULL and reset is set, all functions will be enabled * for tracing. * * This can allocate memory which must be freed before @ops can be freed, * either by removing each filtered addr or by using * ftrace_free_filter(@ops). */int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf, int len, int reset){ ftrace_ops_init(ops); return ftrace_set_regex(ops, buf, len, reset, 0);}EXPORT_SYMBOL_GPL(ftrace_set_notrace);/** * ftrace_set_global_filter - set a function to filter on with global tracers * @buf: the string that holds the function filter text. * @len: the length of the string. * @reset: non-zero to reset all filters before applying this filter. * * Filters denote which functions should be enabled when tracing is enabled. * If @buf is NULL and reset is set, all functions will be enabled for tracing. */void ftrace_set_global_filter(unsigned char *buf, int len, int reset){ ftrace_set_regex(&global_ops, buf, len, reset, 1);}EXPORT_SYMBOL_GPL(ftrace_set_global_filter);
/** * ftrace_set_global_notrace - set a function to not trace with global tracers * @buf: the string that holds the function notrace text. * @len: the length of the string. * @reset: non-zero to reset all filters before applying this filter. * * Notrace Filters denote which functions should not be enabled when tracing * is enabled. If @buf is NULL and reset is set, all functions will be enabled * for tracing. */void ftrace_set_global_notrace(unsigned char *buf, int len, int reset){ ftrace_set_regex(&global_ops, buf, len, reset, 0);}EXPORT_SYMBOL_GPL(ftrace_set_global_notrace);
/* * command line interface to allow users to set filters on boot up. */#define FTRACE_FILTER_SIZE COMMAND_LINE_SIZEstatic char ftrace_notrace_buf[FTRACE_FILTER_SIZE] __initdata;static char ftrace_filter_buf[FTRACE_FILTER_SIZE] __initdata;
/* Used by function selftest to not test if filter is set */bool ftrace_filter_param __initdata;
static int __init set_ftrace_notrace(char *str){ ftrace_filter_param = true; trace_append_boot_param(ftrace_notrace_buf, str, ',', FTRACE_FILTER_SIZE); return 1;}__setup("ftrace_notrace=", set_ftrace_notrace);
static int __init set_ftrace_filter(char *str){ ftrace_filter_param = true; trace_append_boot_param(ftrace_filter_buf, str, ',', FTRACE_FILTER_SIZE); return 1;}__setup("ftrace_filter=", set_ftrace_filter);
#ifdef CONFIG_FUNCTION_GRAPH_TRACERstatic char ftrace_graph_buf[FTRACE_FILTER_SIZE] __initdata;static char ftrace_graph_notrace_buf[FTRACE_FILTER_SIZE] __initdata;static int ftrace_graph_set_hash(struct ftrace_hash *hash, char *buffer);
static int __init set_graph_function(char *str){ trace_append_boot_param(ftrace_graph_buf, str, ',', FTRACE_FILTER_SIZE); return 1;}__setup("ftrace_graph_filter=", set_graph_function);
static int __init set_graph_notrace_function(char *str){ trace_append_boot_param(ftrace_graph_notrace_buf, str, ',', FTRACE_FILTER_SIZE); return 1;}__setup("ftrace_graph_notrace=", set_graph_notrace_function);
static int __init set_graph_max_depth_function(char *str){ if (!str || kstrtouint(str, 0, &fgraph_max_depth)) return 0; return 1;}__setup("ftrace_graph_max_depth=", set_graph_max_depth_function);
static void __init set_ftrace_early_graph(char *buf, int enable){ int ret; char *func; struct ftrace_hash *hash;
hash = alloc_ftrace_hash(FTRACE_HASH_DEFAULT_BITS); if (MEM_FAIL(!hash, "Failed to allocate hash\n")) return;
while (buf) { func = strsep(&buf, ","); /* we allow only one expression at a time */ ret = ftrace_graph_set_hash(hash, func); if (ret) printk(KERN_DEBUG "ftrace: function %s not " "traceable\n", func); }
if (enable) ftrace_graph_hash = hash; else ftrace_graph_notrace_hash = hash;}#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
void __initftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable){ char *func;
ftrace_ops_init(ops);
/* The trace_array is needed for caching module function filters */ if (!ops->private) { struct trace_array *tr = trace_get_global_array();
ops->private = tr; ftrace_init_trace_array(tr); }
while (buf) { func = strsep(&buf, ","); ftrace_set_regex(ops, func, strlen(func), 0, enable); }}
static void __init set_ftrace_early_filters(void){ if (ftrace_filter_buf[0]) ftrace_set_early_filter(&global_ops, ftrace_filter_buf, 1); if (ftrace_notrace_buf[0]) ftrace_set_early_filter(&global_ops, ftrace_notrace_buf, 0);#ifdef CONFIG_FUNCTION_GRAPH_TRACER if (ftrace_graph_buf[0]) set_ftrace_early_graph(ftrace_graph_buf, 1); if (ftrace_graph_notrace_buf[0]) set_ftrace_early_graph(ftrace_graph_notrace_buf, 0);#endif /* CONFIG_FUNCTION_GRAPH_TRACER */}
int ftrace_regex_release(struct inode *inode, struct file *file){ struct seq_file *m = (struct seq_file *)file->private_data; struct ftrace_iterator *iter; struct ftrace_hash **orig_hash; struct trace_parser *parser; int filter_hash;
if (file->f_mode & FMODE_READ) { iter = m->private; seq_release(inode, file); } else iter = file->private_data;
parser = &iter->parser; mutex_lock(&parser_lock); if (trace_parser_loaded(parser)) { int enable = !(iter->flags & FTRACE_ITER_NOTRACE);
ftrace_process_regex(iter, parser->buffer, parser->idx, enable); } mutex_unlock(&parser_lock);
trace_parser_put(parser);
mutex_lock(&iter->ops->func_hash->regex_lock);
if (file->f_mode & FMODE_WRITE) { filter_hash = !!(iter->flags & FTRACE_ITER_FILTER);
if (filter_hash) { orig_hash = &iter->ops->func_hash->filter_hash; if (iter->tr) { if (list_empty(&iter->tr->mod_trace)) iter->hash->flags &= ~FTRACE_HASH_FL_MOD; else iter->hash->flags |= FTRACE_HASH_FL_MOD; } } else orig_hash = &iter->ops->func_hash->notrace_hash;
mutex_lock(&ftrace_lock); ftrace_hash_move_and_update_ops(iter->ops, orig_hash, iter->hash, filter_hash); mutex_unlock(&ftrace_lock); }
mutex_unlock(&iter->ops->func_hash->regex_lock); free_ftrace_hash(iter->hash); if (iter->tr) trace_array_put(iter->tr); kfree(iter);
return 0;}
static const struct file_operations ftrace_avail_fops = { .open = ftrace_avail_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_private,};
static const struct file_operations ftrace_enabled_fops = { .open = ftrace_enabled_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_private,};
static const struct file_operations ftrace_touched_fops = { .open = ftrace_touched_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_private,};
static const struct file_operations ftrace_avail_addrs_fops = { .open = ftrace_avail_addrs_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_private,};
static const struct file_operations ftrace_filter_fops = { .open = ftrace_filter_open, .read = seq_read, .write = ftrace_filter_write, .llseek = tracing_lseek, .release = ftrace_regex_release,};
static const struct file_operations ftrace_notrace_fops = { .open = ftrace_notrace_open, .read = seq_read, .write = ftrace_notrace_write, .llseek = tracing_lseek, .release = ftrace_regex_release,};
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
static DEFINE_MUTEX(graph_lock);
struct ftrace_hash __rcu *ftrace_graph_hash = EMPTY_HASH;struct ftrace_hash __rcu *ftrace_graph_notrace_hash = EMPTY_HASH;
enum graph_filter_type { GRAPH_FILTER_NOTRACE = 0, GRAPH_FILTER_FUNCTION,};
#define FTRACE_GRAPH_EMPTY ((void *)1)
struct ftrace_graph_data { struct ftrace_hash *hash; struct ftrace_func_entry *entry; int idx; /* for hash table iteration */ enum graph_filter_type type; struct ftrace_hash *new_hash; const struct seq_operations *seq_ops; struct trace_parser parser;};
static void *__g_next(struct seq_file *m, loff_t *pos){ struct ftrace_graph_data *fgd = m->private; struct ftrace_func_entry *entry = fgd->entry; struct hlist_head *head; int i, idx = fgd->idx;
if (*pos >= fgd->hash->count) return NULL;
if (entry) { hlist_for_each_entry_continue(entry, hlist) { fgd->entry = entry; return entry; }
idx++; }
for (i = idx; i < 1 << fgd->hash->size_bits; i++) { head = &fgd->hash->buckets[i]; hlist_for_each_entry(entry, head, hlist) { fgd->entry = entry; fgd->idx = i; return entry; } } return NULL;}
static void *g_next(struct seq_file *m, void *v, loff_t *pos){ (*pos)++; return __g_next(m, pos);}
static void *g_start(struct seq_file *m, loff_t *pos){ struct ftrace_graph_data *fgd = m->private;
mutex_lock(&graph_lock);
if (fgd->type == GRAPH_FILTER_FUNCTION) fgd->hash = rcu_dereference_protected(ftrace_graph_hash, lockdep_is_held(&graph_lock)); else fgd->hash = rcu_dereference_protected(ftrace_graph_notrace_hash, lockdep_is_held(&graph_lock));
/* Nothing, tell g_show to print all functions are enabled */ if (ftrace_hash_empty(fgd->hash) && !*pos) return FTRACE_GRAPH_EMPTY;
fgd->idx = 0; fgd->entry = NULL; return __g_next(m, pos);}
static void g_stop(struct seq_file *m, void *p){ mutex_unlock(&graph_lock);}
static int g_show(struct seq_file *m, void *v){ struct ftrace_func_entry *entry = v;
if (!entry) return 0;
if (entry == FTRACE_GRAPH_EMPTY) { struct ftrace_graph_data *fgd = m->private;
if (fgd->type == GRAPH_FILTER_FUNCTION) seq_puts(m, "#### all functions enabled ####\n"); else seq_puts(m, "#### no functions disabled ####\n"); return 0; }
seq_printf(m, "%ps\n", (void *)entry->ip);
return 0;}
static const struct seq_operations ftrace_graph_seq_ops = { .start = g_start, .next = g_next, .stop = g_stop, .show = g_show,};
static int__ftrace_graph_open(struct inode *inode, struct file *file, struct ftrace_graph_data *fgd){ int ret; struct ftrace_hash *new_hash = NULL;
ret = security_locked_down(LOCKDOWN_TRACEFS); if (ret) return ret;
if (file->f_mode & FMODE_WRITE) { const int size_bits = FTRACE_HASH_DEFAULT_BITS;
if (trace_parser_get_init(&fgd->parser, FTRACE_BUFF_MAX)) return -ENOMEM;
if (file->f_flags & O_TRUNC) new_hash = alloc_ftrace_hash(size_bits); else new_hash = alloc_and_copy_ftrace_hash(size_bits, fgd->hash); if (!new_hash) { ret = -ENOMEM; goto out; } }
if (file->f_mode & FMODE_READ) { ret = seq_open(file, &ftrace_graph_seq_ops); if (!ret) { struct seq_file *m = file->private_data; m->private = fgd; } else { /* Failed */ free_ftrace_hash(new_hash); new_hash = NULL; } } else file->private_data = fgd;
out: if (ret < 0 && file->f_mode & FMODE_WRITE) trace_parser_put(&fgd->parser);
fgd->new_hash = new_hash;
/* * All uses of fgd->hash must be taken with the graph_lock * held. The graph_lock is going to be released, so force * fgd->hash to be reinitialized when it is taken again. */ fgd->hash = NULL;
return ret;}
static intftrace_graph_open(struct inode *inode, struct file *file){ struct ftrace_graph_data *fgd; int ret;
if (unlikely(ftrace_disabled)) return -ENODEV;
fgd = kmalloc_obj(*fgd); if (fgd == NULL) return -ENOMEM;
mutex_lock(&graph_lock);
fgd->hash = rcu_dereference_protected(ftrace_graph_hash, lockdep_is_held(&graph_lock)); fgd->type = GRAPH_FILTER_FUNCTION; fgd->seq_ops = &ftrace_graph_seq_ops;
ret = __ftrace_graph_open(inode, file, fgd); if (ret < 0) kfree(fgd);
mutex_unlock(&graph_lock); return ret;}
static intftrace_graph_notrace_open(struct inode *inode, struct file *file){ struct ftrace_graph_data *fgd; int ret;
if (unlikely(ftrace_disabled)) return -ENODEV;
fgd = kmalloc_obj(*fgd); if (fgd == NULL) return -ENOMEM;
mutex_lock(&graph_lock);
fgd->hash = rcu_dereference_protected(ftrace_graph_notrace_hash, lockdep_is_held(&graph_lock)); fgd->type = GRAPH_FILTER_NOTRACE; fgd->seq_ops = &ftrace_graph_seq_ops;
ret = __ftrace_graph_open(inode, file, fgd); if (ret < 0) kfree(fgd);
mutex_unlock(&graph_lock); return ret;}
static intftrace_graph_release(struct inode *inode, struct file *file){ struct ftrace_graph_data *fgd; struct ftrace_hash *old_hash, *new_hash; struct trace_parser *parser; int ret = 0;
if (file->f_mode & FMODE_READ) { struct seq_file *m = file->private_data;
fgd = m->private; seq_release(inode, file); } else { fgd = file->private_data; }
if (file->f_mode & FMODE_WRITE) {
parser = &fgd->parser;
mutex_lock(&parser_lock); if (trace_parser_loaded((parser))) { ret = ftrace_graph_set_hash(fgd->new_hash, parser->buffer); } mutex_unlock(&parser_lock);
trace_parser_put(parser);
new_hash = __ftrace_hash_move(fgd->new_hash); if (!new_hash) { ret = -ENOMEM; goto out; }
mutex_lock(&graph_lock);
if (fgd->type == GRAPH_FILTER_FUNCTION) { old_hash = rcu_dereference_protected(ftrace_graph_hash, lockdep_is_held(&graph_lock)); rcu_assign_pointer(ftrace_graph_hash, new_hash); } else { old_hash = rcu_dereference_protected(ftrace_graph_notrace_hash, lockdep_is_held(&graph_lock)); rcu_assign_pointer(ftrace_graph_notrace_hash, new_hash); }
mutex_unlock(&graph_lock);
/* * We need to do a hard force of sched synchronization. * This is because we use preempt_disable() to do RCU, but * the function tracers can be called where RCU is not watching * (like before user_exit()). We can not rely on the RCU * infrastructure to do the synchronization, thus we must do it * ourselves. */ if (old_hash != EMPTY_HASH) synchronize_rcu_tasks_rude();
free_ftrace_hash(old_hash); }
out: free_ftrace_hash(fgd->new_hash); kfree(fgd);
return ret;}
static intftrace_graph_set_hash(struct ftrace_hash *hash, char *buffer){ struct ftrace_glob func_g; struct dyn_ftrace *rec; struct ftrace_page *pg; struct ftrace_func_entry *entry; int fail = 1; int not;
/* decode regex */ func_g.type = filter_parse_regex(buffer, strlen(buffer), &func_g.search, ¬);
func_g.len = strlen(func_g.search);
guard(mutex)(&ftrace_lock);
if (unlikely(ftrace_disabled)) return -ENODEV;
do_for_each_ftrace_rec(pg, rec) {
if (rec->flags & FTRACE_FL_DISABLED) continue;
if (ftrace_match_record(rec, &func_g, NULL, 0)) { entry = ftrace_lookup_ip(hash, rec->ip);
if (!not) { fail = 0;
if (entry) continue; if (add_hash_entry(hash, rec->ip) == NULL) return 0; } else { if (entry) { free_hash_entry(hash, entry); fail = 0; } } } cond_resched(); } while_for_each_ftrace_rec();
return fail ? -EINVAL : 0;}
static ssize_tftrace_graph_write(struct file *file, const char __user *ubuf, size_t cnt, loff_t *ppos){ ssize_t read, ret = 0; struct ftrace_graph_data *fgd = file->private_data; struct trace_parser *parser;
if (!cnt) return 0;
/* Read mode uses seq functions */ if (file->f_mode & FMODE_READ) { struct seq_file *m = file->private_data; fgd = m->private; }
parser = &fgd->parser;
guard(mutex)(&parser_lock); read = trace_get_user(parser, ubuf, cnt, ppos);
if (read >= 0 && trace_parser_loaded(parser) && !trace_parser_cont(parser)) {
ret = ftrace_graph_set_hash(fgd->new_hash, parser->buffer); trace_parser_clear(parser); }
if (!ret) ret = read;
return ret;}
static const struct file_operations ftrace_graph_fops = { .open = ftrace_graph_open, .read = seq_read, .write = ftrace_graph_write, .llseek = tracing_lseek, .release = ftrace_graph_release,};
static const struct file_operations ftrace_graph_notrace_fops = { .open = ftrace_graph_notrace_open, .read = seq_read, .write = ftrace_graph_write, .llseek = tracing_lseek, .release = ftrace_graph_release,};#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
void ftrace_create_filter_files(struct ftrace_ops *ops, struct dentry *parent){
trace_create_file("set_ftrace_filter", TRACE_MODE_WRITE, parent, ops, &ftrace_filter_fops);
trace_create_file("set_ftrace_notrace", TRACE_MODE_WRITE, parent, ops, &ftrace_notrace_fops);}
/* * The name "destroy_filter_files" is really a misnomer. Although * in the future, it may actually delete the files, but this is * really intended to make sure the ops passed in are disabled * and that when this function returns, the caller is free to * free the ops. * * The "destroy" name is only to match the "create" name that this * should be paired with. */void ftrace_destroy_filter_files(struct ftrace_ops *ops){ mutex_lock(&ftrace_lock); if (ops->flags & FTRACE_OPS_FL_ENABLED) ftrace_shutdown(ops, 0); ops->flags |= FTRACE_OPS_FL_DELETED; ftrace_free_filter(ops); mutex_unlock(&ftrace_lock);}
static __init int ftrace_init_dyn_tracefs(struct dentry *d_tracer){
trace_create_file("available_filter_functions", TRACE_MODE_READ, d_tracer, NULL, &ftrace_avail_fops);
trace_create_file("available_filter_functions_addrs", TRACE_MODE_READ, d_tracer, NULL, &ftrace_avail_addrs_fops);
trace_create_file("enabled_functions", TRACE_MODE_READ, d_tracer, NULL, &ftrace_enabled_fops);
trace_create_file("touched_functions", TRACE_MODE_READ, d_tracer, NULL, &ftrace_touched_fops);
ftrace_create_filter_files(&global_ops, d_tracer);
#ifdef CONFIG_FUNCTION_GRAPH_TRACER trace_create_file("set_graph_function", TRACE_MODE_WRITE, d_tracer, NULL, &ftrace_graph_fops); trace_create_file("set_graph_notrace", TRACE_MODE_WRITE, d_tracer, NULL, &ftrace_graph_notrace_fops);#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
return 0;}
static int ftrace_cmp_ips(const void *a, const void *b){ const unsigned long *ipa = a; const unsigned long *ipb = b;
if (*ipa > *ipb) return 1; if (*ipa < *ipb) return -1; return 0;}
#ifdef CONFIG_FTRACE_SORT_STARTUP_TESTstatic void test_is_sorted(unsigned long *start, unsigned long count){ int i;
for (i = 1; i < count; i++) { if (WARN(start[i - 1] > start[i], "[%d] %pS at %lx is not sorted with %pS at %lx\n", i, (void *)start[i - 1], start[i - 1], (void *)start[i], start[i])) break; } if (i == count) pr_info("ftrace section at %px sorted properly\n", start);}#elsestatic void test_is_sorted(unsigned long *start, unsigned long count){}#endif
static int ftrace_process_locs(struct module *mod, unsigned long *start, unsigned long *end){ struct ftrace_page *pg_unuse = NULL; struct ftrace_page *start_pg; struct ftrace_page *pg; struct dyn_ftrace *rec; unsigned long skipped = 0; unsigned long count; unsigned long *p; unsigned long addr; unsigned long flags = 0; /* Shut up gcc */ unsigned long pages; int ret = -ENOMEM;
count = end - start;
if (!count) return 0;
/* * Sorting mcount in vmlinux at build time depend on * CONFIG_BUILDTIME_MCOUNT_SORT, while mcount loc in * modules can not be sorted at build time. */ if (!IS_ENABLED(CONFIG_BUILDTIME_MCOUNT_SORT) || mod) { sort(start, count, sizeof(*start), ftrace_cmp_ips, NULL); } else { test_is_sorted(start, count); }
start_pg = ftrace_allocate_pages(count, &pages); if (!start_pg) return -ENOMEM;
mutex_lock(&ftrace_lock);
/* * Core and each module needs their own pages, as * modules will free them when they are removed. * Force a new page to be allocated for modules. */ if (!mod) { WARN_ON(ftrace_pages || ftrace_pages_start); /* First initialization */ ftrace_pages = ftrace_pages_start = start_pg; } else { if (!ftrace_pages) goto out;
if (WARN_ON(ftrace_pages->next)) { /* Hmm, we have free pages? */ while (ftrace_pages->next) ftrace_pages = ftrace_pages->next; }
ftrace_pages->next = start_pg; }
p = start; pg = start_pg; while (p < end) { unsigned long end_offset;
addr = *p++;
/* * Some architecture linkers will pad between * the different mcount_loc sections of different * object files to satisfy alignments. * Skip any NULL pointers. */ if (!addr) { skipped++; continue; }
/* * If this is core kernel, make sure the address is in core * or inittext, as weak functions get zeroed and KASLR can * move them to something other than zero. It just will not * move it to an area where kernel text is. */ if (!mod && !(is_kernel_text(addr) || is_kernel_inittext(addr))) { skipped++; continue; }
addr = ftrace_call_adjust(addr);
end_offset = (pg->index+1) * sizeof(pg->records[0]); if (end_offset > PAGE_SIZE << pg->order) { /* We should have allocated enough */ if (WARN_ON(!pg->next)) break; pg = pg->next; }
rec = &pg->records[pg->index++]; rec->ip = addr; }
if (pg->next) { pg_unuse = pg->next; pg->next = NULL; }
/* Assign the last page to ftrace_pages */ ftrace_pages = pg;
/* * We only need to disable interrupts on start up * because we are modifying code that an interrupt * may execute, and the modification is not atomic. * But for modules, nothing runs the code we modify * until we are finished with it, and there's no * reason to cause large interrupt latencies while we do it. */ if (!mod) local_irq_save(flags); ftrace_update_code(mod, start_pg); if (!mod) local_irq_restore(flags); ret = 0; out: mutex_unlock(&ftrace_lock);
/* We should have used all pages unless we skipped some */ if (pg_unuse) { unsigned long pg_remaining, remaining = 0; long skip;
/* Count the number of entries unused and compare it to skipped. */ pg_remaining = ENTRIES_PER_PAGE_GROUP(pg->order) - pg->index;
if (!WARN(skipped < pg_remaining, "Extra allocated pages for ftrace")) {
skip = skipped - pg_remaining;
for (pg = pg_unuse; pg && skip > 0; pg = pg->next) { remaining += 1 << pg->order; skip -= ENTRIES_PER_PAGE_GROUP(pg->order); }
pages -= remaining;
/* * Check to see if the number of pages remaining would * just fit the number of entries skipped. */ WARN(pg || skip > 0, "Extra allocated pages for ftrace: %lu with %lu skipped", remaining, skipped); } /* Need to synchronize with ftrace_location_range() */ synchronize_rcu(); ftrace_free_pages(pg_unuse); }
if (!mod) { count -= skipped; pr_info("ftrace: allocating %ld entries in %ld pages\n", count, pages); }
return ret;}
struct ftrace_mod_func { struct list_head list; char *name; unsigned long ip; unsigned int size;};
struct ftrace_mod_map { struct rcu_head rcu; struct list_head list; struct module *mod; unsigned long start_addr; unsigned long end_addr; struct list_head funcs; unsigned int num_funcs;};
static int ftrace_get_trampoline_kallsym(unsigned int symnum, unsigned long *value, char *type, char *name, char *module_name, int *exported){ struct ftrace_ops *op;
list_for_each_entry_rcu(op, &ftrace_ops_trampoline_list, list) { if (!op->trampoline || symnum--) continue; *value = op->trampoline; *type = 't'; strscpy(name, FTRACE_TRAMPOLINE_SYM, KSYM_NAME_LEN); strscpy(module_name, FTRACE_TRAMPOLINE_MOD, MODULE_NAME_LEN); *exported = 0; return 0; }
return -ERANGE;}
#if defined(CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS) || defined(CONFIG_MODULES)/* * Check if the current ops references the given ip. * * If the ops traces all functions, then it was already accounted for. * If the ops does not trace the current record function, skip it. * If the ops ignores the function via notrace filter, skip it. */static boolops_references_ip(struct ftrace_ops *ops, unsigned long ip){ /* If ops isn't enabled, ignore it */ if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) return false;
/* If ops traces all then it includes this function */ if (ops_traces_mod(ops)) return true;
/* The function must be in the filter */ if (!ftrace_hash_empty(ops->func_hash->filter_hash) && !__ftrace_lookup_ip(ops->func_hash->filter_hash, ip)) return false;
/* If in notrace hash, we ignore it too */ if (ftrace_lookup_ip(ops->func_hash->notrace_hash, ip)) return false;
return true;}#endif
#ifdef CONFIG_MODULES
#define next_to_ftrace_page(p) container_of(p, struct ftrace_page, next)
static LIST_HEAD(ftrace_mod_maps);
static int referenced_filters(struct dyn_ftrace *rec){ struct ftrace_ops *ops; int cnt = 0;
for (ops = ftrace_ops_list; ops != &ftrace_list_end; ops = ops->next) { if (ops_references_ip(ops, rec->ip)) { if (WARN_ON_ONCE(ops->flags & FTRACE_OPS_FL_DIRECT)) continue; if (WARN_ON_ONCE(ops->flags & FTRACE_OPS_FL_IPMODIFY)) continue; cnt++; if (ops->flags & FTRACE_OPS_FL_SAVE_REGS) rec->flags |= FTRACE_FL_REGS; if (cnt == 1 && ops->trampoline) rec->flags |= FTRACE_FL_TRAMP; else rec->flags &= ~FTRACE_FL_TRAMP; } }
return cnt;}
static voidclear_mod_from_hash(struct ftrace_page *pg, struct ftrace_hash *hash){ struct ftrace_func_entry *entry; struct dyn_ftrace *rec; int i;
if (ftrace_hash_empty(hash)) return;
for (i = 0; i < pg->index; i++) { rec = &pg->records[i]; entry = __ftrace_lookup_ip(hash, rec->ip); /* * Do not allow this rec to match again. * Yeah, it may waste some memory, but will be removed * if/when the hash is modified again. */ if (entry) entry->ip = 0; }}
/* Clear any records from hashes */static void clear_mod_from_hashes(struct ftrace_page *pg){ struct trace_array *tr;
mutex_lock(&trace_types_lock); list_for_each_entry(tr, &ftrace_trace_arrays, list) { if (!tr->ops || !tr->ops->func_hash) continue; mutex_lock(&tr->ops->func_hash->regex_lock); clear_mod_from_hash(pg, tr->ops->func_hash->filter_hash); clear_mod_from_hash(pg, tr->ops->func_hash->notrace_hash); mutex_unlock(&tr->ops->func_hash->regex_lock); } mutex_unlock(&trace_types_lock);}
static void ftrace_free_mod_map(struct rcu_head *rcu){ struct ftrace_mod_map *mod_map = container_of(rcu, struct ftrace_mod_map, rcu); struct ftrace_mod_func *mod_func; struct ftrace_mod_func *n;
/* All the contents of mod_map are now not visible to readers */ list_for_each_entry_safe(mod_func, n, &mod_map->funcs, list) { kfree(mod_func->name); list_del(&mod_func->list); kfree(mod_func); }
kfree(mod_map);}
void ftrace_release_mod(struct module *mod){ struct ftrace_mod_map *mod_map; struct ftrace_mod_map *n; struct dyn_ftrace *rec; struct ftrace_page **last_pg; struct ftrace_page *tmp_page = NULL; struct ftrace_page *pg;
mutex_lock(&ftrace_lock);
/* * To avoid the UAF problem after the module is unloaded, the * 'mod_map' resource needs to be released unconditionally. */ list_for_each_entry_safe(mod_map, n, &ftrace_mod_maps, list) { if (mod_map->mod == mod) { list_del_rcu(&mod_map->list); call_rcu(&mod_map->rcu, ftrace_free_mod_map); break; } }
if (ftrace_disabled) goto out_unlock;
/* * Each module has its own ftrace_pages, remove * them from the list. */ last_pg = &ftrace_pages_start; for (pg = ftrace_pages_start; pg; pg = *last_pg) { rec = &pg->records[0]; if (within_module(rec->ip, mod)) { /* * As core pages are first, the first * page should never be a module page. */ if (WARN_ON(pg == ftrace_pages_start)) goto out_unlock;
/* Check if we are deleting the last page */ if (pg == ftrace_pages) ftrace_pages = next_to_ftrace_page(last_pg);
ftrace_update_tot_cnt -= pg->index; *last_pg = pg->next;
pg->next = tmp_page; tmp_page = pg; } else last_pg = &pg->next; } out_unlock: mutex_unlock(&ftrace_lock);
/* Need to synchronize with ftrace_location_range() */ if (tmp_page) synchronize_rcu(); for (pg = tmp_page; pg; pg = tmp_page) {
/* Needs to be called outside of ftrace_lock */ clear_mod_from_hashes(pg);
if (pg->records) { free_pages((unsigned long)pg->records, pg->order); ftrace_number_of_pages -= 1 << pg->order; } tmp_page = pg->next; kfree(pg); ftrace_number_of_groups--; }}
void ftrace_module_enable(struct module *mod){ struct dyn_ftrace *rec; struct ftrace_page *pg;
mutex_lock(&ftrace_lock);
if (ftrace_disabled) goto out_unlock;
/* * If the tracing is enabled, go ahead and enable the record. * * The reason not to enable the record immediately is the * inherent check of ftrace_make_nop/ftrace_make_call for * correct previous instructions. Making first the NOP * conversion puts the module to the correct state, thus * passing the ftrace_make_call check. * * We also delay this to after the module code already set the * text to read-only, as we now need to set it back to read-write * so that we can modify the text. */ if (ftrace_start_up) ftrace_arch_code_modify_prepare();
do_for_each_ftrace_rec(pg, rec) { int cnt; /* * do_for_each_ftrace_rec() is a double loop. * module text shares the pg. If a record is * not part of this module, then skip this pg, * which the "break" will do. */ if (!within_module(rec->ip, mod)) break;
cond_resched();
/* Weak functions should still be ignored */ if (!test_for_valid_rec(rec)) { /* Clear all other flags. Should not be enabled anyway */ rec->flags = FTRACE_FL_DISABLED; continue; }
cnt = 0;
/* * When adding a module, we need to check if tracers are * currently enabled and if they are, and can trace this record, * we need to enable the module functions as well as update the * reference counts for those function records. */ if (ftrace_start_up) cnt += referenced_filters(rec);
rec->flags &= ~FTRACE_FL_DISABLED; rec->flags += cnt;
if (ftrace_start_up && cnt) { int failed = __ftrace_replace_code(rec, 1); if (failed) { ftrace_bug(failed, rec); goto out_loop; } }
} while_for_each_ftrace_rec();
out_loop: if (ftrace_start_up) ftrace_arch_code_modify_post_process();
out_unlock: mutex_unlock(&ftrace_lock);
process_cached_mods(mod->name);}
void ftrace_module_init(struct module *mod){ int ret;
if (ftrace_disabled || !mod->num_ftrace_callsites) return;
ret = ftrace_process_locs(mod, mod->ftrace_callsites, mod->ftrace_callsites + mod->num_ftrace_callsites); if (ret) pr_warn("ftrace: failed to allocate entries for module '%s' functions\n", mod->name);}
static void save_ftrace_mod_rec(struct ftrace_mod_map *mod_map, struct dyn_ftrace *rec){ struct ftrace_mod_func *mod_func; unsigned long symsize; unsigned long offset; char str[KSYM_SYMBOL_LEN]; char *modname; const char *ret;
ret = kallsyms_lookup(rec->ip, &symsize, &offset, &modname, str); if (!ret) return;
mod_func = kmalloc_obj(*mod_func); if (!mod_func) return;
mod_func->name = kstrdup(str, GFP_KERNEL); if (!mod_func->name) { kfree(mod_func); return; }
mod_func->ip = rec->ip - offset; mod_func->size = symsize;
mod_map->num_funcs++;
list_add_rcu(&mod_func->list, &mod_map->funcs);}
static struct ftrace_mod_map *allocate_ftrace_mod_map(struct module *mod, unsigned long start, unsigned long end){ struct ftrace_mod_map *mod_map;
if (ftrace_disabled) return NULL;
mod_map = kmalloc_obj(*mod_map); if (!mod_map) return NULL;
mod_map->mod = mod; mod_map->start_addr = start; mod_map->end_addr = end; mod_map->num_funcs = 0;
INIT_LIST_HEAD_RCU(&mod_map->funcs);
list_add_rcu(&mod_map->list, &ftrace_mod_maps);
return mod_map;}
static intftrace_func_address_lookup(struct ftrace_mod_map *mod_map, unsigned long addr, unsigned long *size, unsigned long *off, char *sym){ struct ftrace_mod_func *found_func = NULL; struct ftrace_mod_func *mod_func;
list_for_each_entry_rcu(mod_func, &mod_map->funcs, list) { if (addr >= mod_func->ip && addr < mod_func->ip + mod_func->size) { found_func = mod_func; break; } }
if (found_func) { if (size) *size = found_func->size; if (off) *off = addr - found_func->ip; return strscpy(sym, found_func->name, KSYM_NAME_LEN); }
return 0;}
intftrace_mod_address_lookup(unsigned long addr, unsigned long *size, unsigned long *off, char **modname, const unsigned char **modbuildid, char *sym){ struct ftrace_mod_map *mod_map; int ret = 0;
/* mod_map is freed via call_rcu() */ preempt_disable(); list_for_each_entry_rcu(mod_map, &ftrace_mod_maps, list) { ret = ftrace_func_address_lookup(mod_map, addr, size, off, sym); if (ret) { if (modname) *modname = mod_map->mod->name; if (modbuildid) *modbuildid = module_buildid(mod_map->mod); break; } } preempt_enable();
return ret;}
int ftrace_mod_get_kallsym(unsigned int symnum, unsigned long *value, char *type, char *name, char *module_name, int *exported){ struct ftrace_mod_map *mod_map; struct ftrace_mod_func *mod_func; int ret;
preempt_disable(); list_for_each_entry_rcu(mod_map, &ftrace_mod_maps, list) {
if (symnum >= mod_map->num_funcs) { symnum -= mod_map->num_funcs; continue; }
list_for_each_entry_rcu(mod_func, &mod_map->funcs, list) { if (symnum > 1) { symnum--; continue; }
*value = mod_func->ip; *type = 'T'; strscpy(name, mod_func->name, KSYM_NAME_LEN); strscpy(module_name, mod_map->mod->name, MODULE_NAME_LEN); *exported = 1; preempt_enable(); return 0; } WARN_ON(1); break; } ret = ftrace_get_trampoline_kallsym(symnum, value, type, name, module_name, exported); preempt_enable(); return ret;}
#elsestatic void save_ftrace_mod_rec(struct ftrace_mod_map *mod_map, struct dyn_ftrace *rec) { }static inline struct ftrace_mod_map *allocate_ftrace_mod_map(struct module *mod, unsigned long start, unsigned long end){ return NULL;}int ftrace_mod_get_kallsym(unsigned int symnum, unsigned long *value, char *type, char *name, char *module_name, int *exported){ int ret;
preempt_disable(); ret = ftrace_get_trampoline_kallsym(symnum, value, type, name, module_name, exported); preempt_enable(); return ret;}#endif /* CONFIG_MODULES */
struct ftrace_init_func { struct list_head list; unsigned long ip;};
/* Clear any init ips from hashes */static voidclear_func_from_hash(struct ftrace_init_func *func, struct ftrace_hash *hash){ struct ftrace_func_entry *entry;
entry = ftrace_lookup_ip(hash, func->ip); /* * Do not allow this rec to match again. * Yeah, it may waste some memory, but will be removed * if/when the hash is modified again. */ if (entry) entry->ip = 0;}
static voidclear_func_from_hashes(struct ftrace_init_func *func){ struct trace_array *tr;
mutex_lock(&trace_types_lock); list_for_each_entry(tr, &ftrace_trace_arrays, list) { if (!tr->ops || !tr->ops->func_hash) continue; mutex_lock(&tr->ops->func_hash->regex_lock); clear_func_from_hash(func, tr->ops->func_hash->filter_hash); clear_func_from_hash(func, tr->ops->func_hash->notrace_hash); mutex_unlock(&tr->ops->func_hash->regex_lock); } mutex_unlock(&trace_types_lock);}
static void add_to_clear_hash_list(struct list_head *clear_list, struct dyn_ftrace *rec){ struct ftrace_init_func *func;
func = kmalloc_obj(*func); if (!func) { MEM_FAIL(1, "alloc failure, ftrace filter could be stale\n"); return; }
func->ip = rec->ip; list_add(&func->list, clear_list);}
void ftrace_free_mem(struct module *mod, void *start_ptr, void *end_ptr){ unsigned long start = (unsigned long)(start_ptr); unsigned long end = (unsigned long)(end_ptr); struct ftrace_page **last_pg = &ftrace_pages_start; struct ftrace_page *tmp_page = NULL; struct ftrace_page *pg; struct dyn_ftrace *rec; struct dyn_ftrace key; struct ftrace_mod_map *mod_map = NULL; struct ftrace_init_func *func, *func_next; LIST_HEAD(clear_hash);
key.ip = start; key.flags = end; /* overload flags, as it is unsigned long */
mutex_lock(&ftrace_lock);
/* * If we are freeing module init memory, then check if * any tracer is active. If so, we need to save a mapping of * the module functions being freed with the address. */ if (mod && ftrace_ops_list != &ftrace_list_end) mod_map = allocate_ftrace_mod_map(mod, start, end);
for (pg = ftrace_pages_start; pg; last_pg = &pg->next, pg = *last_pg) { if (end < pg->records[0].ip || start >= (pg->records[pg->index - 1].ip + MCOUNT_INSN_SIZE)) continue; again: rec = bsearch(&key, pg->records, pg->index, sizeof(struct dyn_ftrace), ftrace_cmp_recs); if (!rec) continue;
/* rec will be cleared from hashes after ftrace_lock unlock */ add_to_clear_hash_list(&clear_hash, rec);
if (mod_map) save_ftrace_mod_rec(mod_map, rec);
pg->index--; ftrace_update_tot_cnt--; if (!pg->index) { *last_pg = pg->next; pg->next = tmp_page; tmp_page = pg; pg = container_of(last_pg, struct ftrace_page, next); if (!(*last_pg)) ftrace_pages = pg; continue; } memmove(rec, rec + 1, (pg->index - (rec - pg->records)) * sizeof(*rec)); /* More than one function may be in this block */ goto again; } mutex_unlock(&ftrace_lock);
list_for_each_entry_safe(func, func_next, &clear_hash, list) { clear_func_from_hashes(func); kfree(func); } /* Need to synchronize with ftrace_location_range() */ if (tmp_page) { synchronize_rcu(); ftrace_free_pages(tmp_page); }}
void __init ftrace_free_init_mem(void){ void *start = (void *)(&__init_begin); void *end = (void *)(&__init_end);
ftrace_boot_snapshot();
ftrace_free_mem(NULL, start, end);}
int __init __weak ftrace_dyn_arch_init(void){ return 0;}
void __init ftrace_init(void){ extern unsigned long __start_mcount_loc[]; extern unsigned long __stop_mcount_loc[]; unsigned long count, flags; int ret;
local_irq_save(flags); ret = ftrace_dyn_arch_init(); local_irq_restore(flags); if (ret) goto failed;
count = __stop_mcount_loc - __start_mcount_loc; if (!count) { pr_info("ftrace: No functions to be traced?\n"); goto failed; }
ret = ftrace_process_locs(NULL, __start_mcount_loc, __stop_mcount_loc); if (ret) { pr_warn("ftrace: failed to allocate entries for functions\n"); goto failed; }
pr_info("ftrace: allocated %ld pages with %ld groups\n", ftrace_number_of_pages, ftrace_number_of_groups);
last_ftrace_enabled = ftrace_enabled = 1;
set_ftrace_early_filters();
return; failed: ftrace_disabled = 1;}
/* Do nothing if arch does not support this */void __weak arch_ftrace_update_trampoline(struct ftrace_ops *ops){}
static void ftrace_update_trampoline(struct ftrace_ops *ops){ unsigned long trampoline = ops->trampoline;
arch_ftrace_update_trampoline(ops); if (ops->trampoline && ops->trampoline != trampoline && (ops->flags & FTRACE_OPS_FL_ALLOC_TRAMP)) { /* Add to kallsyms before the perf events */ ftrace_add_trampoline_to_kallsyms(ops); perf_event_ksymbol(PERF_RECORD_KSYMBOL_TYPE_OOL, ops->trampoline, ops->trampoline_size, false, FTRACE_TRAMPOLINE_SYM); /* * Record the perf text poke event after the ksymbol register * event. */ perf_event_text_poke((void *)ops->trampoline, NULL, 0, (void *)ops->trampoline, ops->trampoline_size); }}
void ftrace_init_trace_array(struct trace_array *tr){ if (tr->flags & TRACE_ARRAY_FL_MOD_INIT) return;
INIT_LIST_HEAD(&tr->func_probes); INIT_LIST_HEAD(&tr->mod_trace); INIT_LIST_HEAD(&tr->mod_notrace);
tr->flags |= TRACE_ARRAY_FL_MOD_INIT;}#else
struct ftrace_ops global_ops = { .func = ftrace_stub, .flags = FTRACE_OPS_FL_INITIALIZED | FTRACE_OPS_FL_PID,};
static int __init ftrace_nodyn_init(void){ ftrace_enabled = 1; return 0;}core_initcall(ftrace_nodyn_init);
static inline int ftrace_init_dyn_tracefs(struct dentry *d_tracer) { return 0; }static inline void ftrace_startup_all(int command) { }
static void ftrace_update_trampoline(struct ftrace_ops *ops){}
#endif /* CONFIG_DYNAMIC_FTRACE */
__init void ftrace_init_global_array_ops(struct trace_array *tr){ tr->ops = &global_ops; if (!global_ops.private) global_ops.private = tr; ftrace_init_trace_array(tr); init_array_fgraph_ops(tr, tr->ops);}
void ftrace_init_array_ops(struct trace_array *tr, ftrace_func_t func){ /* If we filter on pids, update to use the pid function */ if (tr->flags & TRACE_ARRAY_FL_GLOBAL) { if (WARN_ON(tr->ops->func != ftrace_stub)) printk("ftrace ops had %pS for function\n", tr->ops->func); } tr->ops->func = func; tr->ops->private = tr;}
void ftrace_reset_array_ops(struct trace_array *tr){ tr->ops->func = ftrace_stub;}
static nokprobe_inline void__ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *ignored, struct ftrace_regs *fregs){ struct pt_regs *regs = ftrace_get_regs(fregs); struct ftrace_ops *op; int bit;
/* * The ftrace_test_and_set_recursion() will disable preemption, * which is required since some of the ops may be dynamically * allocated, they must be freed after a synchronize_rcu(). */ bit = trace_test_and_set_recursion(ip, parent_ip, TRACE_LIST_START); if (bit < 0) return;
do_for_each_ftrace_op(op, ftrace_ops_list) { /* Stub functions don't need to be called nor tested */ if (op->flags & FTRACE_OPS_FL_STUB) continue; /* * Check the following for each ops before calling their func: * if RCU flag is set, then rcu_is_watching() must be true * Otherwise test if the ip matches the ops filter * * If any of the above fails then the op->func() is not executed. */ if ((!(op->flags & FTRACE_OPS_FL_RCU) || rcu_is_watching()) && ftrace_ops_test(op, ip, regs)) { if (FTRACE_WARN_ON(!op->func)) { pr_warn("op=%p %pS\n", op, op); goto out; } op->func(ip, parent_ip, op, fregs); } } while_for_each_ftrace_op(op);out: trace_clear_recursion(bit);}
/* * Some archs only support passing ip and parent_ip. Even though * the list function ignores the op parameter, we do not want any * C side effects, where a function is called without the caller * sending a third parameter. * Archs are to support both the regs and ftrace_ops at the same time. * If they support ftrace_ops, it is assumed they support regs. * If call backs want to use regs, they must either check for regs * being NULL, or CONFIG_DYNAMIC_FTRACE_WITH_REGS. * Note, CONFIG_DYNAMIC_FTRACE_WITH_REGS expects a full regs to be saved. * An architecture can pass partial regs with ftrace_ops and still * set the ARCH_SUPPORTS_FTRACE_OPS. * * In vmlinux.lds.h, ftrace_ops_list_func() is defined to be * arch_ftrace_ops_list_func. */#if ARCH_SUPPORTS_FTRACE_OPSvoid arch_ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct ftrace_regs *fregs){ kmsan_unpoison_memory(fregs, ftrace_regs_size()); __ftrace_ops_list_func(ip, parent_ip, NULL, fregs);}#elsevoid arch_ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip){ __ftrace_ops_list_func(ip, parent_ip, NULL, NULL);}#endifNOKPROBE_SYMBOL(arch_ftrace_ops_list_func);
/* * If there's only one function registered but it does not support * recursion, needs RCU protection, then this function will be called * by the mcount trampoline. */static void ftrace_ops_assist_func(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct ftrace_regs *fregs){ int bit;
bit = trace_test_and_set_recursion(ip, parent_ip, TRACE_LIST_START); if (bit < 0) return;
if (!(op->flags & FTRACE_OPS_FL_RCU) || rcu_is_watching()) op->func(ip, parent_ip, op, fregs);
trace_clear_recursion(bit);}NOKPROBE_SYMBOL(ftrace_ops_assist_func);
/** * ftrace_ops_get_func - get the function a trampoline should call * @ops: the ops to get the function for * * Normally the mcount trampoline will call the ops->func, but there * are times that it should not. For example, if the ops does not * have its own recursion protection, then it should call the * ftrace_ops_assist_func() instead. * * Returns: the function that the trampoline should call for @ops. */ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops){ /* * If the function does not handle recursion or needs to be RCU safe, * then we need to call the assist handler. */ if (ops->flags & (FTRACE_OPS_FL_RECURSION | FTRACE_OPS_FL_RCU)) return ftrace_ops_assist_func;
return ops->func;}
static voidftrace_filter_pid_sched_switch_probe(void *data, bool preempt, struct task_struct *prev, struct task_struct *next, unsigned int prev_state){ struct trace_array *tr = data; struct trace_pid_list *pid_list; struct trace_pid_list *no_pid_list;
pid_list = rcu_dereference_sched(tr->function_pids); no_pid_list = rcu_dereference_sched(tr->function_no_pids);
if (trace_ignore_this_task(pid_list, no_pid_list, next)) this_cpu_write(tr->array_buffer.data->ftrace_ignore_pid, FTRACE_PID_IGNORE); else this_cpu_write(tr->array_buffer.data->ftrace_ignore_pid, next->pid);}
static voidftrace_pid_follow_sched_process_fork(void *data, struct task_struct *self, struct task_struct *task){ struct trace_pid_list *pid_list; struct trace_array *tr = data;
guard(preempt)(); pid_list = rcu_dereference_sched(tr->function_pids); trace_filter_add_remove_task(pid_list, self, task);
pid_list = rcu_dereference_sched(tr->function_no_pids); trace_filter_add_remove_task(pid_list, self, task);}
static voidftrace_pid_follow_sched_process_exit(void *data, struct task_struct *task){ struct trace_pid_list *pid_list; struct trace_array *tr = data;
guard(preempt)(); pid_list = rcu_dereference_sched(tr->function_pids); trace_filter_add_remove_task(pid_list, NULL, task);
pid_list = rcu_dereference_sched(tr->function_no_pids); trace_filter_add_remove_task(pid_list, NULL, task);}
void ftrace_pid_follow_fork(struct trace_array *tr, bool enable){ if (enable) { register_trace_sched_process_fork(ftrace_pid_follow_sched_process_fork, tr); register_trace_sched_process_free(ftrace_pid_follow_sched_process_exit, tr); } else { unregister_trace_sched_process_fork(ftrace_pid_follow_sched_process_fork, tr); unregister_trace_sched_process_free(ftrace_pid_follow_sched_process_exit, tr); }}
static void clear_ftrace_pids(struct trace_array *tr, int type){ struct trace_pid_list *pid_list; struct trace_pid_list *no_pid_list; int cpu;
pid_list = rcu_dereference_protected(tr->function_pids, lockdep_is_held(&ftrace_lock)); no_pid_list = rcu_dereference_protected(tr->function_no_pids, lockdep_is_held(&ftrace_lock));
/* Make sure there's something to do */ if (!pid_type_enabled(type, pid_list, no_pid_list)) return;
/* See if the pids still need to be checked after this */ if (!still_need_pid_events(type, pid_list, no_pid_list)) { unregister_trace_sched_switch(ftrace_filter_pid_sched_switch_probe, tr); for_each_possible_cpu(cpu) per_cpu_ptr(tr->array_buffer.data, cpu)->ftrace_ignore_pid = FTRACE_PID_TRACE; }
if (type & TRACE_PIDS) rcu_assign_pointer(tr->function_pids, NULL);
if (type & TRACE_NO_PIDS) rcu_assign_pointer(tr->function_no_pids, NULL);
/* Wait till all users are no longer using pid filtering */ synchronize_rcu();
if ((type & TRACE_PIDS) && pid_list) trace_pid_list_free(pid_list);
if ((type & TRACE_NO_PIDS) && no_pid_list) trace_pid_list_free(no_pid_list);}
void ftrace_clear_pids(struct trace_array *tr){ mutex_lock(&ftrace_lock);
clear_ftrace_pids(tr, TRACE_PIDS | TRACE_NO_PIDS);
mutex_unlock(&ftrace_lock);}
static void ftrace_pid_reset(struct trace_array *tr, int type){ mutex_lock(&ftrace_lock); clear_ftrace_pids(tr, type);
ftrace_update_pid_func(); ftrace_startup_all(0);
mutex_unlock(&ftrace_lock);}
/* Greater than any max PID */#define FTRACE_NO_PIDS (void *)(PID_MAX_LIMIT + 1)
static void *fpid_start(struct seq_file *m, loff_t *pos) __acquires(RCU){ struct trace_pid_list *pid_list; struct trace_array *tr = m->private;
mutex_lock(&ftrace_lock); rcu_read_lock_sched();
pid_list = rcu_dereference_sched(tr->function_pids);
if (!pid_list) return !(*pos) ? FTRACE_NO_PIDS : NULL;
return trace_pid_start(pid_list, pos);}
static void *fpid_next(struct seq_file *m, void *v, loff_t *pos){ struct trace_array *tr = m->private; struct trace_pid_list *pid_list = rcu_dereference_sched(tr->function_pids);
if (v == FTRACE_NO_PIDS) { (*pos)++; return NULL; } return trace_pid_next(pid_list, v, pos);}
static void fpid_stop(struct seq_file *m, void *p) __releases(RCU){ rcu_read_unlock_sched(); mutex_unlock(&ftrace_lock);}
static int fpid_show(struct seq_file *m, void *v){ if (v == FTRACE_NO_PIDS) { seq_puts(m, "no pid\n"); return 0; }
return trace_pid_show(m, v);}
static const struct seq_operations ftrace_pid_sops = { .start = fpid_start, .next = fpid_next, .stop = fpid_stop, .show = fpid_show,};
static void *fnpid_start(struct seq_file *m, loff_t *pos) __acquires(RCU){ struct trace_pid_list *pid_list; struct trace_array *tr = m->private;
mutex_lock(&ftrace_lock); rcu_read_lock_sched();
pid_list = rcu_dereference_sched(tr->function_no_pids);
if (!pid_list) return !(*pos) ? FTRACE_NO_PIDS : NULL;
return trace_pid_start(pid_list, pos);}
static void *fnpid_next(struct seq_file *m, void *v, loff_t *pos){ struct trace_array *tr = m->private; struct trace_pid_list *pid_list = rcu_dereference_sched(tr->function_no_pids);
if (v == FTRACE_NO_PIDS) { (*pos)++; return NULL; } return trace_pid_next(pid_list, v, pos);}
static const struct seq_operations ftrace_no_pid_sops = { .start = fnpid_start, .next = fnpid_next, .stop = fpid_stop, .show = fpid_show,};
static int pid_open(struct inode *inode, struct file *file, int type){ const struct seq_operations *seq_ops; struct trace_array *tr = inode->i_private; struct seq_file *m; int ret = 0;
ret = tracing_check_open_get_tr(tr); if (ret) return ret;
if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) ftrace_pid_reset(tr, type);
switch (type) { case TRACE_PIDS: seq_ops = &ftrace_pid_sops; break; case TRACE_NO_PIDS: seq_ops = &ftrace_no_pid_sops; break; default: trace_array_put(tr); WARN_ON_ONCE(1); return -EINVAL; }
ret = seq_open(file, seq_ops); if (ret < 0) { trace_array_put(tr); } else { m = file->private_data; /* copy tr over to seq ops */ m->private = tr; }
return ret;}
static intftrace_pid_open(struct inode *inode, struct file *file){ return pid_open(inode, file, TRACE_PIDS);}
static intftrace_no_pid_open(struct inode *inode, struct file *file){ return pid_open(inode, file, TRACE_NO_PIDS);}
static void ignore_task_cpu(void *data){ struct trace_array *tr = data; struct trace_pid_list *pid_list; struct trace_pid_list *no_pid_list;
/* * This function is called by on_each_cpu() while the * event_mutex is held. */ pid_list = rcu_dereference_protected(tr->function_pids, mutex_is_locked(&ftrace_lock)); no_pid_list = rcu_dereference_protected(tr->function_no_pids, mutex_is_locked(&ftrace_lock));
if (trace_ignore_this_task(pid_list, no_pid_list, current)) this_cpu_write(tr->array_buffer.data->ftrace_ignore_pid, FTRACE_PID_IGNORE); else this_cpu_write(tr->array_buffer.data->ftrace_ignore_pid, current->pid);}
static ssize_tpid_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *ppos, int type){ struct seq_file *m = filp->private_data; struct trace_array *tr = m->private; struct trace_pid_list *filtered_pids; struct trace_pid_list *other_pids; struct trace_pid_list *pid_list; ssize_t ret;
if (!cnt) return 0;
guard(mutex)(&ftrace_lock);
switch (type) { case TRACE_PIDS: filtered_pids = rcu_dereference_protected(tr->function_pids, lockdep_is_held(&ftrace_lock)); other_pids = rcu_dereference_protected(tr->function_no_pids, lockdep_is_held(&ftrace_lock)); break; case TRACE_NO_PIDS: filtered_pids = rcu_dereference_protected(tr->function_no_pids, lockdep_is_held(&ftrace_lock)); other_pids = rcu_dereference_protected(tr->function_pids, lockdep_is_held(&ftrace_lock)); break; default: WARN_ON_ONCE(1); return -EINVAL; }
ret = trace_pid_write(filtered_pids, &pid_list, ubuf, cnt); if (ret < 0) return ret;
switch (type) { case TRACE_PIDS: rcu_assign_pointer(tr->function_pids, pid_list); break; case TRACE_NO_PIDS: rcu_assign_pointer(tr->function_no_pids, pid_list); break; }
if (filtered_pids) { synchronize_rcu(); trace_pid_list_free(filtered_pids); } else if (pid_list && !other_pids) { /* Register a probe to set whether to ignore the tracing of a task */ register_trace_sched_switch(ftrace_filter_pid_sched_switch_probe, tr); }
/* * Ignoring of pids is done at task switch. But we have to * check for those tasks that are currently running. * Always do this in case a pid was appended or removed. */ on_each_cpu(ignore_task_cpu, tr, 1);
ftrace_update_pid_func(); ftrace_startup_all(0);
*ppos += ret;
return ret;}
static ssize_tftrace_pid_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *ppos){ return pid_write(filp, ubuf, cnt, ppos, TRACE_PIDS);}
static ssize_tftrace_no_pid_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *ppos){ return pid_write(filp, ubuf, cnt, ppos, TRACE_NO_PIDS);}
static intftrace_pid_release(struct inode *inode, struct file *file){ struct trace_array *tr = inode->i_private;
trace_array_put(tr);
return seq_release(inode, file);}
static const struct file_operations ftrace_pid_fops = { .open = ftrace_pid_open, .write = ftrace_pid_write, .read = seq_read, .llseek = tracing_lseek, .release = ftrace_pid_release,};
static const struct file_operations ftrace_no_pid_fops = { .open = ftrace_no_pid_open, .write = ftrace_no_pid_write, .read = seq_read, .llseek = tracing_lseek, .release = ftrace_pid_release,};
void ftrace_init_tracefs(struct trace_array *tr, struct dentry *d_tracer){ trace_create_file("set_ftrace_pid", TRACE_MODE_WRITE, d_tracer, tr, &ftrace_pid_fops); trace_create_file("set_ftrace_notrace_pid", TRACE_MODE_WRITE, d_tracer, tr, &ftrace_no_pid_fops);}
void __init ftrace_init_tracefs_toplevel(struct trace_array *tr, struct dentry *d_tracer){ /* Only the top level directory has the dyn_tracefs and profile */ WARN_ON(!(tr->flags & TRACE_ARRAY_FL_GLOBAL));
ftrace_init_dyn_tracefs(d_tracer); ftrace_profile_tracefs(d_tracer);}
/** * ftrace_kill - kill ftrace * * This function should be used by panic code. It stops ftrace * but in a not so nice way. If you need to simply kill ftrace * from a non-atomic section, use ftrace_kill. */void ftrace_kill(void){ ftrace_disabled = 1; ftrace_enabled = 0; ftrace_trace_function = ftrace_stub; kprobe_ftrace_kill();}
/** * ftrace_is_dead - Test if ftrace is dead or not. * * Returns: 1 if ftrace is "dead", zero otherwise. */int ftrace_is_dead(void){ return ftrace_disabled;}
#ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS/* * When registering ftrace_ops with IPMODIFY, it is necessary to make sure * it doesn't conflict with any direct ftrace_ops. If there is existing * direct ftrace_ops on a kernel function being patched, call * FTRACE_OPS_CMD_ENABLE_SHARE_IPMODIFY_PEER on it to enable sharing. * * @ops: ftrace_ops being registered. * * Returns: * 0 on success; * Negative on failure. */static int prepare_direct_functions_for_ipmodify(struct ftrace_ops *ops){ struct ftrace_func_entry *entry; struct ftrace_hash *hash; struct ftrace_ops *op; int size, i, ret;
lockdep_assert_held_once(&direct_mutex);
if (!(ops->flags & FTRACE_OPS_FL_IPMODIFY)) return 0;
hash = ops->func_hash->filter_hash; size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &hash->buckets[i], hlist) { unsigned long ip = entry->ip; bool found_op = false;
mutex_lock(&ftrace_lock); do_for_each_ftrace_op(op, ftrace_ops_list) { if (!(op->flags & FTRACE_OPS_FL_DIRECT)) continue; if (ops_references_ip(op, ip)) { found_op = true; break; } } while_for_each_ftrace_op(op); mutex_unlock(&ftrace_lock);
if (found_op) { if (!op->ops_func) return -EBUSY;
ret = op->ops_func(op, ip, FTRACE_OPS_CMD_ENABLE_SHARE_IPMODIFY_PEER); if (ret) return ret; } } }
return 0;}
/* * Similar to prepare_direct_functions_for_ipmodify, clean up after ops * with IPMODIFY is unregistered. The cleanup is optional for most DIRECT * ops. */static void cleanup_direct_functions_after_ipmodify(struct ftrace_ops *ops){ struct ftrace_func_entry *entry; struct ftrace_hash *hash; struct ftrace_ops *op; int size, i;
if (!(ops->flags & FTRACE_OPS_FL_IPMODIFY)) return;
mutex_lock(&direct_mutex);
hash = ops->func_hash->filter_hash; size = 1 << hash->size_bits; for (i = 0; i < size; i++) { hlist_for_each_entry(entry, &hash->buckets[i], hlist) { unsigned long ip = entry->ip; bool found_op = false;
mutex_lock(&ftrace_lock); do_for_each_ftrace_op(op, ftrace_ops_list) { if (!(op->flags & FTRACE_OPS_FL_DIRECT)) continue; if (ops_references_ip(op, ip)) { found_op = true; break; } } while_for_each_ftrace_op(op); mutex_unlock(&ftrace_lock);
/* The cleanup is optional, ignore any errors */ if (found_op && op->ops_func) op->ops_func(op, ip, FTRACE_OPS_CMD_DISABLE_SHARE_IPMODIFY_PEER); } } mutex_unlock(&direct_mutex);}
#define lock_direct_mutex() mutex_lock(&direct_mutex)#define unlock_direct_mutex() mutex_unlock(&direct_mutex)
#else /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */
static int prepare_direct_functions_for_ipmodify(struct ftrace_ops *ops){ return 0;}
static void cleanup_direct_functions_after_ipmodify(struct ftrace_ops *ops){}
#define lock_direct_mutex() do { } while (0)#define unlock_direct_mutex() do { } while (0)
#endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */
/* * Similar to register_ftrace_function, except we don't lock direct_mutex. */static int register_ftrace_function_nolock(struct ftrace_ops *ops){ int ret;
ftrace_ops_init(ops);
mutex_lock(&ftrace_lock);
ret = ftrace_startup(ops, 0);
mutex_unlock(&ftrace_lock);
return ret;}
/** * register_ftrace_function - register a function for profiling * @ops: ops structure that holds the function for profiling. * * Register a function to be called by all functions in the * kernel. * * Note: @ops->func and all the functions it calls must be labeled * with "notrace", otherwise it will go into a * recursive loop. */int register_ftrace_function(struct ftrace_ops *ops){ int ret;
lock_direct_mutex(); ret = prepare_direct_functions_for_ipmodify(ops); if (ret < 0) goto out_unlock;
ret = register_ftrace_function_nolock(ops);
out_unlock: unlock_direct_mutex(); return ret;}EXPORT_SYMBOL_GPL(register_ftrace_function);
/** * unregister_ftrace_function - unregister a function for profiling. * @ops: ops structure that holds the function to unregister * * Unregister a function that was added to be called by ftrace profiling. */int unregister_ftrace_function(struct ftrace_ops *ops){ int ret;
mutex_lock(&ftrace_lock); ret = ftrace_shutdown(ops, 0); mutex_unlock(&ftrace_lock);
cleanup_direct_functions_after_ipmodify(ops); return ret;}EXPORT_SYMBOL_GPL(unregister_ftrace_function);
static int symbols_cmp(const void *a, const void *b){ const char **str_a = (const char **) a; const char **str_b = (const char **) b;
return strcmp(*str_a, *str_b);}
struct kallsyms_data { unsigned long *addrs; const char **syms; size_t cnt; size_t found;};
/* This function gets called for all kernel and module symbols * and returns 1 in case we resolved all the requested symbols, * 0 otherwise. */static int kallsyms_callback(void *data, const char *name, unsigned long addr){ struct kallsyms_data *args = data; const char **sym; int idx;
sym = bsearch(&name, args->syms, args->cnt, sizeof(*args->syms), symbols_cmp); if (!sym) return 0;
idx = sym - args->syms; if (args->addrs[idx]) return 0;
if (!ftrace_location(addr)) return 0;
args->addrs[idx] = addr; args->found++; return args->found == args->cnt ? 1 : 0;}
/** * ftrace_lookup_symbols - Lookup addresses for array of symbols * * @sorted_syms: array of symbols pointers symbols to resolve, * must be alphabetically sorted * @cnt: number of symbols/addresses in @syms/@addrs arrays * @addrs: array for storing resulting addresses * * This function looks up addresses for array of symbols provided in * @syms array (must be alphabetically sorted) and stores them in * @addrs array, which needs to be big enough to store at least @cnt * addresses. * * For a single symbol (cnt == 1), uses kallsyms_lookup_name() which * performs an O(log N) binary search via the sorted kallsyms index. * This avoids the full O(N) linear scan over all kernel symbols that * the multi-symbol path requires. * * For multiple symbols, uses a single-pass linear scan via * kallsyms_on_each_symbol() with binary search into the sorted input * array. * * Returns: 0 if all provided symbols are found, -ESRCH otherwise. */int ftrace_lookup_symbols(const char **sorted_syms, size_t cnt, unsigned long *addrs){ struct kallsyms_data args; int found_all;
/* Fast path: single symbol uses O(log N) binary search */ if (cnt == 1) { addrs[0] = kallsyms_lookup_name(sorted_syms[0]); if (addrs[0] && ftrace_location(addrs[0])) return 0; /* * Binary lookup can fail for duplicate symbol names * where the first match is not ftrace-instrumented. * Retry with linear scan. */ }
/* Batch path: single-pass O(N) linear scan */ memset(addrs, 0, sizeof(*addrs) * cnt); args.addrs = addrs; args.syms = sorted_syms; args.cnt = cnt; args.found = 0;
found_all = kallsyms_on_each_symbol(kallsyms_callback, &args); if (found_all) return 0; found_all = module_kallsyms_on_each_symbol(NULL, kallsyms_callback, &args); return found_all ? 0 : -ESRCH;}
#ifdef CONFIG_SYSCTL
#ifdef CONFIG_DYNAMIC_FTRACEstatic void ftrace_startup_sysctl(void){ int command;
if (unlikely(ftrace_disabled)) return;
/* Force update next time */ saved_ftrace_func = NULL; /* ftrace_start_up is true if we want ftrace running */ if (ftrace_start_up) { command = FTRACE_UPDATE_CALLS; if (ftrace_graph_active) command |= FTRACE_START_FUNC_RET; ftrace_startup_enable(command); }}
static void ftrace_shutdown_sysctl(void){ int command;
if (unlikely(ftrace_disabled)) return;
/* ftrace_start_up is true if ftrace is running */ if (ftrace_start_up) { command = FTRACE_DISABLE_CALLS; if (ftrace_graph_active) command |= FTRACE_STOP_FUNC_RET; ftrace_run_update_code(command); }}#else# define ftrace_startup_sysctl() do { } while (0)# define ftrace_shutdown_sysctl() do { } while (0)#endif /* CONFIG_DYNAMIC_FTRACE */
static bool is_permanent_ops_registered(void){ struct ftrace_ops *op;
do_for_each_ftrace_op(op, ftrace_ops_list) { if (op->flags & FTRACE_OPS_FL_PERMANENT) return true; } while_for_each_ftrace_op(op);
return false;}
static intftrace_enable_sysctl(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos){ int ret;
guard(mutex)(&ftrace_lock);
if (unlikely(ftrace_disabled)) return -ENODEV;
ret = proc_dointvec(table, write, buffer, lenp, ppos);
if (ret || !write || (last_ftrace_enabled == !!ftrace_enabled)) return ret;
if (ftrace_enabled) {
/* we are starting ftrace again */ if (rcu_dereference_protected(ftrace_ops_list, lockdep_is_held(&ftrace_lock)) != &ftrace_list_end) update_ftrace_function();
ftrace_startup_sysctl();
} else { if (is_permanent_ops_registered()) { ftrace_enabled = true; return -EBUSY; }
/* stopping ftrace calls (just send to ftrace_stub) */ ftrace_trace_function = ftrace_stub;
ftrace_shutdown_sysctl(); }
last_ftrace_enabled = !!ftrace_enabled; return 0;}
static const struct ctl_table ftrace_sysctls[] = { { .procname = "ftrace_enabled", .data = &ftrace_enabled, .maxlen = sizeof(int), .mode = 0644, .proc_handler = ftrace_enable_sysctl, },};
static int __init ftrace_sysctl_init(void){ register_sysctl_init("kernel", ftrace_sysctls); return 0;}late_initcall(ftrace_sysctl_init);#endif