123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070507150725073507450755076507750785079508050815082508350845085508650875088508950905091509250935094509550965097509850995100510151025103510451055106510751085109511051115112511351145115511651175118511951205121512251235124512551265127512851295130513151325133513451355136513751385139514051415142514351445145514651475148514951505151515251535154515551565157515851595160516151625163516451655166516751685169517051715172517351745175517651775178517951805181518251835184518551865187518851895190519151925193519451955196519751985199520052015202520352045205520652075208520952105211521252135214521552165217521852195220522152225223522452255226522752285229523052315232523352345235523652375238523952405241524252435244524552465247524852495250525152525253525452555256525752585259526052615262526352645265526652675268526952705271527252735274527552765277527852795280528152825283528452855286528752885289529052915292529352945295529652975298529953005301530253035304530553065307530853095310531153125313531453155316531753185319532053215322532353245325532653275328532953305331533253335334533553365337533853395340534153425343534453455346534753485349535053515352535353545355535653575358535953605361536253635364536553665367536853695370537153725373537453755376537753785379538053815382538353845385538653875388538953905391539253935394539553965397539853995400540154025403540454055406540754085409541054115412541354145415541654175418541954205421542254235424542554265427542854295430543154325433543454355436543754385439544054415442544354445445544654475448544954505451545254535454545554565457545854595460546154625463546454655466546754685469547054715472547354745475547654775478547954805481548254835484548554865487548854895490549154925493549454955496549754985499550055015502550355045505550655075508550955105511551255135514551555165517551855195520552155225523552455255526552755285529553055315532553355345535553655375538553955405541554255435544554555465547554855495550555155525553555455555556555755585559556055615562556355645565556655675568556955705571557255735574557555765577557855795580558155825583558455855586558755885589559055915592559355945595559655975598559956005601560256035604560556065607560856095610561156125613561456155616561756185619562056215622562356245625562656275628562956305631563256335634563556365637563856395640564156425643564456455646564756485649565056515652565356545655565656575658565956605661566256635664566556665667566856695670567156725673567456755676567756785679568056815682568356845685568656875688568956905691569256935694569556965697569856995700570157025703570457055706570757085709571057115712571357145715571657175718571957205721572257235724572557265727572857295730573157325733573457355736573757385739574057415742574357445745574657475748574957505751575257535754575557565757575857595760576157625763576457655766576757685769577057715772577357745775577657775778577957805781578257835784578557865787578857895790579157925793579457955796579757985799580058015802580358045805580658075808580958105811581258135814581558165817581858195820582158225823582458255826582758285829583058315832583358345835583658375838583958405841584258435844584558465847584858495850585158525853585458555856585758585859586058615862586358645865586658675868586958705871587258735874587558765877587858795880588158825883588458855886588758885889589058915892589358945895589658975898589959005901590259035904590559065907590859095910591159125913591459155916591759185919592059215922592359245925592659275928592959305931593259335934593559365937593859395940594159425943594459455946594759485949595059515952595359545955595659575958595959605961596259635964596559665967596859695970597159725973597459755976597759785979598059815982598359845985598659875988598959905991599259935994599559965997599859996000600160026003600460056006600760086009601060116012601360146015601660176018601960206021602260236024602560266027602860296030603160326033603460356036603760386039604060416042604360446045604660476048604960506051605260536054605560566057605860596060606160626063606460656066606760686069607060716072607360746075607660776078607960806081608260836084608560866087608860896090609160926093609460956096609760986099610061016102610361046105610661076108610961106111611261136114611561166117611861196120612161226123612461256126612761286129613061316132613361346135613661376138613961406141614261436144614561466147614861496150615161526153615461556156615761586159616061616162616361646165616661676168616961706171617261736174617561766177617861796180618161826183618461856186618761886189619061916192619361946195619661976198619962006201620262036204620562066207620862096210621162126213621462156216621762186219622062216222622362246225622662276228622962306231623262336234623562366237623862396240624162426243624462456246624762486249625062516252625362546255625662576258625962606261626262636264626562666267626862696270627162726273627462756276627762786279628062816282628362846285628662876288628962906291629262936294629562966297629862996300630163026303630463056306630763086309631063116312631363146315631663176318631963206321632263236324632563266327632863296330633163326333633463356336633763386339634063416342634363446345634663476348634963506351635263536354635563566357635863596360636163626363636463656366636763686369637063716372637363746375637663776378637963806381638263836384638563866387638863896390639163926393639463956396639763986399640064016402640364046405640664076408640964106411641264136414641564166417641864196420642164226423642464256426642764286429643064316432643364346435643664376438643964406441644264436444644564466447644864496450645164526453645464556456645764586459646064616462646364646465646664676468646964706471647264736474647564766477647864796480648164826483648464856486648764886489649064916492649364946495649664976498649965006501650265036504650565066507650865096510651165126513651465156516651765186519652065216522652365246525652665276528652965306531653265336534653565366537653865396540654165426543654465456546654765486549655065516552655365546555655665576558655965606561656265636564656565666567656865696570657165726573657465756576657765786579658065816582658365846585658665876588658965906591659265936594659565966597659865996600660166026603660466056606660766086609661066116612661366146615661666176618661966206621662266236624662566266627662866296630663166326633663466356636663766386639664066416642664366446645664666476648664966506651665266536654665566566657665866596660666166626663666466656666666766686669667066716672667366746675667666776678667966806681668266836684668566866687668866896690669166926693669466956696669766986699670067016702670367046705670667076708670967106711671267136714671567166717671867196720672167226723672467256726672767286729673067316732673367346735673667376738673967406741674267436744674567466747674867496750675167526753675467556756675767586759676067616762676367646765676667676768676967706771677267736774677567766777677867796780678167826783678467856786678767886789679067916792679367946795679667976798679968006801680268036804680568066807680868096810681168126813681468156816681768186819682068216822682368246825682668276828682968306831683268336834683568366837683868396840684168426843684468456846684768486849685068516852685368546855685668576858685968606861686268636864686568666867686868696870687168726873687468756876687768786879688068816882688368846885688668876888688968906891689268936894689568966897689868996900690169026903690469056906690769086909691069116912691369146915691669176918691969206921692269236924692569266927692869296930693169326933693469356936693769386939694069416942694369446945694669476948694969506951695269536954695569566957695869596960696169626963696469656966696769686969697069716972697369746975697669776978697969806981698269836984698569866987698869896990699169926993699469956996699769986999700070017002700370047005700670077008700970107011701270137014701570167017701870197020702170227023702470257026702770287029703070317032703370347035703670377038703970407041704270437044704570467047704870497050705170527053 |
- /* Low level interface to ptrace, for the remote server for GDB.
- Copyright (C) 1995-2022 Free Software Foundation, Inc.
- This file is part of GDB.
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- (at your option) any later version.
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
- #include "server.h"
- #include "linux-low.h"
- #include "nat/linux-osdata.h"
- #include "gdbsupport/agent.h"
- #include "tdesc.h"
- #include "gdbsupport/event-loop.h"
- #include "gdbsupport/event-pipe.h"
- #include "gdbsupport/rsp-low.h"
- #include "gdbsupport/signals-state-save-restore.h"
- #include "nat/linux-nat.h"
- #include "nat/linux-waitpid.h"
- #include "gdbsupport/gdb_wait.h"
- #include "nat/gdb_ptrace.h"
- #include "nat/linux-ptrace.h"
- #include "nat/linux-procfs.h"
- #include "nat/linux-personality.h"
- #include <signal.h>
- #include <sys/ioctl.h>
- #include <fcntl.h>
- #include <unistd.h>
- #include <sys/syscall.h>
- #include <sched.h>
- #include <ctype.h>
- #include <pwd.h>
- #include <sys/types.h>
- #include <dirent.h>
- #include <sys/stat.h>
- #include <sys/vfs.h>
- #include <sys/uio.h>
- #include "gdbsupport/filestuff.h"
- #include "tracepoint.h"
- #include <inttypes.h>
- #include "gdbsupport/common-inferior.h"
- #include "nat/fork-inferior.h"
- #include "gdbsupport/environ.h"
- #include "gdbsupport/gdb-sigmask.h"
- #include "gdbsupport/scoped_restore.h"
- #ifndef ELFMAG0
- /* Don't include <linux/elf.h> here. If it got included by gdb_proc_service.h
- then ELFMAG0 will have been defined. If it didn't get included by
- gdb_proc_service.h then including it will likely introduce a duplicate
- definition of elf_fpregset_t. */
- #include <elf.h>
- #endif
- #include "nat/linux-namespaces.h"
- #ifndef O_LARGEFILE
- #define O_LARGEFILE 0
- #endif
- #ifndef AT_HWCAP2
- #define AT_HWCAP2 26
- #endif
- /* Some targets did not define these ptrace constants from the start,
- so gdbserver defines them locally here. In the future, these may
- be removed after they are added to asm/ptrace.h. */
- #if !(defined(PT_TEXT_ADDR) \
- || defined(PT_DATA_ADDR) \
- || defined(PT_TEXT_END_ADDR))
- #if defined(__mcoldfire__)
- /* These are still undefined in 3.10 kernels. */
- #define PT_TEXT_ADDR 49*4
- #define PT_DATA_ADDR 50*4
- #define PT_TEXT_END_ADDR 51*4
- /* These are still undefined in 3.10 kernels. */
- #elif defined(__TMS320C6X__)
- #define PT_TEXT_ADDR (0x10000*4)
- #define PT_DATA_ADDR (0x10004*4)
- #define PT_TEXT_END_ADDR (0x10008*4)
- #endif
- #endif
- #if (defined(__UCLIBC__) \
- && defined(HAS_NOMMU) \
- && defined(PT_TEXT_ADDR) \
- && defined(PT_DATA_ADDR) \
- && defined(PT_TEXT_END_ADDR))
- #define SUPPORTS_READ_OFFSETS
- #endif
- #ifdef HAVE_LINUX_BTRACE
- # include "nat/linux-btrace.h"
- # include "gdbsupport/btrace-common.h"
- #endif
- #ifndef HAVE_ELF32_AUXV_T
- /* Copied from glibc's elf.h. */
- typedef struct
- {
- uint32_t a_type; /* Entry type */
- union
- {
- uint32_t a_val; /* Integer value */
- /* We use to have pointer elements added here. We cannot do that,
- though, since it does not work when using 32-bit definitions
- on 64-bit platforms and vice versa. */
- } a_un;
- } Elf32_auxv_t;
- #endif
- #ifndef HAVE_ELF64_AUXV_T
- /* Copied from glibc's elf.h. */
- typedef struct
- {
- uint64_t a_type; /* Entry type */
- union
- {
- uint64_t a_val; /* Integer value */
- /* We use to have pointer elements added here. We cannot do that,
- though, since it does not work when using 32-bit definitions
- on 64-bit platforms and vice versa. */
- } a_un;
- } Elf64_auxv_t;
- #endif
- /* Does the current host support PTRACE_GETREGSET? */
- int have_ptrace_getregset = -1;
- /* Return TRUE if THREAD is the leader thread of the process. */
- static bool
- is_leader (thread_info *thread)
- {
- ptid_t ptid = ptid_of (thread);
- return ptid.pid () == ptid.lwp ();
- }
- /* LWP accessors. */
- /* See nat/linux-nat.h. */
- ptid_t
- ptid_of_lwp (struct lwp_info *lwp)
- {
- return ptid_of (get_lwp_thread (lwp));
- }
- /* See nat/linux-nat.h. */
- void
- lwp_set_arch_private_info (struct lwp_info *lwp,
- struct arch_lwp_info *info)
- {
- lwp->arch_private = info;
- }
- /* See nat/linux-nat.h. */
- struct arch_lwp_info *
- lwp_arch_private_info (struct lwp_info *lwp)
- {
- return lwp->arch_private;
- }
- /* See nat/linux-nat.h. */
- int
- lwp_is_stopped (struct lwp_info *lwp)
- {
- return lwp->stopped;
- }
- /* See nat/linux-nat.h. */
- enum target_stop_reason
- lwp_stop_reason (struct lwp_info *lwp)
- {
- return lwp->stop_reason;
- }
- /* See nat/linux-nat.h. */
- int
- lwp_is_stepping (struct lwp_info *lwp)
- {
- return lwp->stepping;
- }
- /* A list of all unknown processes which receive stop signals. Some
- other process will presumably claim each of these as forked
- children momentarily. */
- struct simple_pid_list
- {
- /* The process ID. */
- int pid;
- /* The status as reported by waitpid. */
- int status;
- /* Next in chain. */
- struct simple_pid_list *next;
- };
- static struct simple_pid_list *stopped_pids;
- /* Trivial list manipulation functions to keep track of a list of new
- stopped processes. */
- static void
- add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
- {
- struct simple_pid_list *new_pid = XNEW (struct simple_pid_list);
- new_pid->pid = pid;
- new_pid->status = status;
- new_pid->next = *listp;
- *listp = new_pid;
- }
- static int
- pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
- {
- struct simple_pid_list **p;
- for (p = listp; *p != NULL; p = &(*p)->next)
- if ((*p)->pid == pid)
- {
- struct simple_pid_list *next = (*p)->next;
- *statusp = (*p)->status;
- xfree (*p);
- *p = next;
- return 1;
- }
- return 0;
- }
- enum stopping_threads_kind
- {
- /* Not stopping threads presently. */
- NOT_STOPPING_THREADS,
- /* Stopping threads. */
- STOPPING_THREADS,
- /* Stopping and suspending threads. */
- STOPPING_AND_SUSPENDING_THREADS
- };
- /* This is set while stop_all_lwps is in effect. */
- static stopping_threads_kind stopping_threads = NOT_STOPPING_THREADS;
- /* FIXME make into a target method? */
- int using_threads = 1;
- /* True if we're presently stabilizing threads (moving them out of
- jump pads). */
- static int stabilizing_threads;
- static void unsuspend_all_lwps (struct lwp_info *except);
- static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
- static int lwp_is_marked_dead (struct lwp_info *lwp);
- static int kill_lwp (unsigned long lwpid, int signo);
- static void enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info);
- static int linux_low_ptrace_options (int attached);
- static int check_ptrace_stopped_lwp_gone (struct lwp_info *lp);
- /* When the event-loop is doing a step-over, this points at the thread
- being stepped. */
- static ptid_t step_over_bkpt;
- bool
- linux_process_target::low_supports_breakpoints ()
- {
- return false;
- }
- CORE_ADDR
- linux_process_target::low_get_pc (regcache *regcache)
- {
- return 0;
- }
- void
- linux_process_target::low_set_pc (regcache *regcache, CORE_ADDR newpc)
- {
- gdb_assert_not_reached ("linux target op low_set_pc is not implemented");
- }
- std::vector<CORE_ADDR>
- linux_process_target::low_get_next_pcs (regcache *regcache)
- {
- gdb_assert_not_reached ("linux target op low_get_next_pcs is not "
- "implemented");
- }
- int
- linux_process_target::low_decr_pc_after_break ()
- {
- return 0;
- }
- /* True if LWP is stopped in its stepping range. */
- static int
- lwp_in_step_range (struct lwp_info *lwp)
- {
- CORE_ADDR pc = lwp->stop_pc;
- return (pc >= lwp->step_range_start && pc < lwp->step_range_end);
- }
- /* The event pipe registered as a waitable file in the event loop. */
- static event_pipe linux_event_pipe;
- /* True if we're currently in async mode. */
- #define target_is_async_p() (linux_event_pipe.is_open ())
- static void send_sigstop (struct lwp_info *lwp);
- /* Return non-zero if HEADER is a 64-bit ELF file. */
- static int
- elf_64_header_p (const Elf64_Ehdr *header, unsigned int *machine)
- {
- if (header->e_ident[EI_MAG0] == ELFMAG0
- && header->e_ident[EI_MAG1] == ELFMAG1
- && header->e_ident[EI_MAG2] == ELFMAG2
- && header->e_ident[EI_MAG3] == ELFMAG3)
- {
- *machine = header->e_machine;
- return header->e_ident[EI_CLASS] == ELFCLASS64;
- }
- *machine = EM_NONE;
- return -1;
- }
- /* Return non-zero if FILE is a 64-bit ELF file,
- zero if the file is not a 64-bit ELF file,
- and -1 if the file is not accessible or doesn't exist. */
- static int
- elf_64_file_p (const char *file, unsigned int *machine)
- {
- Elf64_Ehdr header;
- int fd;
- fd = open (file, O_RDONLY);
- if (fd < 0)
- return -1;
- if (read (fd, &header, sizeof (header)) != sizeof (header))
- {
- close (fd);
- return 0;
- }
- close (fd);
- return elf_64_header_p (&header, machine);
- }
- /* Accepts an integer PID; Returns true if the executable PID is
- running is a 64-bit ELF file.. */
- int
- linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine)
- {
- char file[PATH_MAX];
- sprintf (file, "/proc/%d/exe", pid);
- return elf_64_file_p (file, machine);
- }
- void
- linux_process_target::delete_lwp (lwp_info *lwp)
- {
- struct thread_info *thr = get_lwp_thread (lwp);
- threads_debug_printf ("deleting %ld", lwpid_of (thr));
- remove_thread (thr);
- low_delete_thread (lwp->arch_private);
- delete lwp;
- }
- void
- linux_process_target::low_delete_thread (arch_lwp_info *info)
- {
- /* Default implementation should be overridden if architecture-specific
- info is being used. */
- gdb_assert (info == nullptr);
- }
- process_info *
- linux_process_target::add_linux_process (int pid, int attached)
- {
- struct process_info *proc;
- proc = add_process (pid, attached);
- proc->priv = XCNEW (struct process_info_private);
- proc->priv->arch_private = low_new_process ();
- return proc;
- }
- arch_process_info *
- linux_process_target::low_new_process ()
- {
- return nullptr;
- }
- void
- linux_process_target::low_delete_process (arch_process_info *info)
- {
- /* Default implementation must be overridden if architecture-specific
- info exists. */
- gdb_assert (info == nullptr);
- }
- void
- linux_process_target::low_new_fork (process_info *parent, process_info *child)
- {
- /* Nop. */
- }
- void
- linux_process_target::arch_setup_thread (thread_info *thread)
- {
- scoped_restore_current_thread restore_thread;
- switch_to_thread (thread);
- low_arch_setup ();
- }
- int
- linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp,
- int wstat)
- {
- client_state &cs = get_client_state ();
- struct lwp_info *event_lwp = *orig_event_lwp;
- int event = linux_ptrace_get_extended_event (wstat);
- struct thread_info *event_thr = get_lwp_thread (event_lwp);
- struct lwp_info *new_lwp;
- gdb_assert (event_lwp->waitstatus.kind () == TARGET_WAITKIND_IGNORE);
- /* All extended events we currently use are mid-syscall. Only
- PTRACE_EVENT_STOP is delivered more like a signal-stop, but
- you have to be using PTRACE_SEIZE to get that. */
- event_lwp->syscall_state = TARGET_WAITKIND_SYSCALL_ENTRY;
- if ((event == PTRACE_EVENT_FORK) || (event == PTRACE_EVENT_VFORK)
- || (event == PTRACE_EVENT_CLONE))
- {
- ptid_t ptid;
- unsigned long new_pid;
- int ret, status;
- /* Get the pid of the new lwp. */
- ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_thr), (PTRACE_TYPE_ARG3) 0,
- &new_pid);
- /* If we haven't already seen the new PID stop, wait for it now. */
- if (!pull_pid_from_list (&stopped_pids, new_pid, &status))
- {
- /* The new child has a pending SIGSTOP. We can't affect it until it
- hits the SIGSTOP, but we're already attached. */
- ret = my_waitpid (new_pid, &status, __WALL);
- if (ret == -1)
- perror_with_name ("waiting for new child");
- else if (ret != new_pid)
- warning ("wait returned unexpected PID %d", ret);
- else if (!WIFSTOPPED (status))
- warning ("wait returned unexpected status 0x%x", status);
- }
- if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
- {
- struct process_info *parent_proc;
- struct process_info *child_proc;
- struct lwp_info *child_lwp;
- struct thread_info *child_thr;
- ptid = ptid_t (new_pid, new_pid);
- threads_debug_printf ("Got fork event from LWP %ld, "
- "new child is %d",
- ptid_of (event_thr).lwp (),
- ptid.pid ());
- /* Add the new process to the tables and clone the breakpoint
- lists of the parent. We need to do this even if the new process
- will be detached, since we will need the process object and the
- breakpoints to remove any breakpoints from memory when we
- detach, and the client side will access registers. */
- child_proc = add_linux_process (new_pid, 0);
- gdb_assert (child_proc != NULL);
- child_lwp = add_lwp (ptid);
- gdb_assert (child_lwp != NULL);
- child_lwp->stopped = 1;
- child_lwp->must_set_ptrace_flags = 1;
- child_lwp->status_pending_p = 0;
- child_thr = get_lwp_thread (child_lwp);
- child_thr->last_resume_kind = resume_stop;
- child_thr->last_status.set_stopped (GDB_SIGNAL_0);
- /* If we're suspending all threads, leave this one suspended
- too. If the fork/clone parent is stepping over a breakpoint,
- all other threads have been suspended already. Leave the
- child suspended too. */
- if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS
- || event_lwp->bp_reinsert != 0)
- {
- threads_debug_printf ("leaving child suspended");
- child_lwp->suspended = 1;
- }
- parent_proc = get_thread_process (event_thr);
- child_proc->attached = parent_proc->attached;
- if (event_lwp->bp_reinsert != 0
- && supports_software_single_step ()
- && event == PTRACE_EVENT_VFORK)
- {
- /* If we leave single-step breakpoints there, child will
- hit it, so uninsert single-step breakpoints from parent
- (and child). Once vfork child is done, reinsert
- them back to parent. */
- uninsert_single_step_breakpoints (event_thr);
- }
- clone_all_breakpoints (child_thr, event_thr);
- target_desc_up tdesc = allocate_target_description ();
- copy_target_description (tdesc.get (), parent_proc->tdesc);
- child_proc->tdesc = tdesc.release ();
- /* Clone arch-specific process data. */
- low_new_fork (parent_proc, child_proc);
- /* Save fork info in the parent thread. */
- if (event == PTRACE_EVENT_FORK)
- event_lwp->waitstatus.set_forked (ptid);
- else if (event == PTRACE_EVENT_VFORK)
- event_lwp->waitstatus.set_vforked (ptid);
- /* The status_pending field contains bits denoting the
- extended event, so when the pending event is handled,
- the handler will look at lwp->waitstatus. */
- event_lwp->status_pending_p = 1;
- event_lwp->status_pending = wstat;
- /* Link the threads until the parent event is passed on to
- higher layers. */
- event_lwp->fork_relative = child_lwp;
- child_lwp->fork_relative = event_lwp;
- /* If the parent thread is doing step-over with single-step
- breakpoints, the list of single-step breakpoints are cloned
- from the parent's. Remove them from the child process.
- In case of vfork, we'll reinsert them back once vforked
- child is done. */
- if (event_lwp->bp_reinsert != 0
- && supports_software_single_step ())
- {
- /* The child process is forked and stopped, so it is safe
- to access its memory without stopping all other threads
- from other processes. */
- delete_single_step_breakpoints (child_thr);
- gdb_assert (has_single_step_breakpoints (event_thr));
- gdb_assert (!has_single_step_breakpoints (child_thr));
- }
- /* Report the event. */
- return 0;
- }
- threads_debug_printf
- ("Got clone event from LWP %ld, new child is LWP %ld",
- lwpid_of (event_thr), new_pid);
- ptid = ptid_t (pid_of (event_thr), new_pid);
- new_lwp = add_lwp (ptid);
- /* Either we're going to immediately resume the new thread
- or leave it stopped. resume_one_lwp is a nop if it
- thinks the thread is currently running, so set this first
- before calling resume_one_lwp. */
- new_lwp->stopped = 1;
- /* If we're suspending all threads, leave this one suspended
- too. If the fork/clone parent is stepping over a breakpoint,
- all other threads have been suspended already. Leave the
- child suspended too. */
- if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS
- || event_lwp->bp_reinsert != 0)
- new_lwp->suspended = 1;
- /* Normally we will get the pending SIGSTOP. But in some cases
- we might get another signal delivered to the group first.
- If we do get another signal, be sure not to lose it. */
- if (WSTOPSIG (status) != SIGSTOP)
- {
- new_lwp->stop_expected = 1;
- new_lwp->status_pending_p = 1;
- new_lwp->status_pending = status;
- }
- else if (cs.report_thread_events)
- {
- new_lwp->waitstatus.set_thread_created ();
- new_lwp->status_pending_p = 1;
- new_lwp->status_pending = status;
- }
- #ifdef USE_THREAD_DB
- thread_db_notice_clone (event_thr, ptid);
- #endif
- /* Don't report the event. */
- return 1;
- }
- else if (event == PTRACE_EVENT_VFORK_DONE)
- {
- event_lwp->waitstatus.set_vfork_done ();
- if (event_lwp->bp_reinsert != 0 && supports_software_single_step ())
- {
- reinsert_single_step_breakpoints (event_thr);
- gdb_assert (has_single_step_breakpoints (event_thr));
- }
- /* Report the event. */
- return 0;
- }
- else if (event == PTRACE_EVENT_EXEC && cs.report_exec_events)
- {
- struct process_info *proc;
- std::vector<int> syscalls_to_catch;
- ptid_t event_ptid;
- pid_t event_pid;
- threads_debug_printf ("Got exec event from LWP %ld",
- lwpid_of (event_thr));
- /* Get the event ptid. */
- event_ptid = ptid_of (event_thr);
- event_pid = event_ptid.pid ();
- /* Save the syscall list from the execing process. */
- proc = get_thread_process (event_thr);
- syscalls_to_catch = std::move (proc->syscalls_to_catch);
- /* Delete the execing process and all its threads. */
- mourn (proc);
- switch_to_thread (nullptr);
- /* Create a new process/lwp/thread. */
- proc = add_linux_process (event_pid, 0);
- event_lwp = add_lwp (event_ptid);
- event_thr = get_lwp_thread (event_lwp);
- gdb_assert (current_thread == event_thr);
- arch_setup_thread (event_thr);
- /* Set the event status. */
- event_lwp->waitstatus.set_execd
- (make_unique_xstrdup
- (linux_proc_pid_to_exec_file (lwpid_of (event_thr))));
- /* Mark the exec status as pending. */
- event_lwp->stopped = 1;
- event_lwp->status_pending_p = 1;
- event_lwp->status_pending = wstat;
- event_thr->last_resume_kind = resume_continue;
- event_thr->last_status.set_ignore ();
- /* Update syscall state in the new lwp, effectively mid-syscall too. */
- event_lwp->syscall_state = TARGET_WAITKIND_SYSCALL_ENTRY;
- /* Restore the list to catch. Don't rely on the client, which is free
- to avoid sending a new list when the architecture doesn't change.
- Also, for ANY_SYSCALL, the architecture doesn't really matter. */
- proc->syscalls_to_catch = std::move (syscalls_to_catch);
- /* Report the event. */
- *orig_event_lwp = event_lwp;
- return 0;
- }
- internal_error (__FILE__, __LINE__, _("unknown ptrace event %d"), event);
- }
- CORE_ADDR
- linux_process_target::get_pc (lwp_info *lwp)
- {
- struct regcache *regcache;
- CORE_ADDR pc;
- if (!low_supports_breakpoints ())
- return 0;
- scoped_restore_current_thread restore_thread;
- switch_to_thread (get_lwp_thread (lwp));
- regcache = get_thread_regcache (current_thread, 1);
- pc = low_get_pc (regcache);
- threads_debug_printf ("pc is 0x%lx", (long) pc);
- return pc;
- }
- void
- linux_process_target::get_syscall_trapinfo (lwp_info *lwp, int *sysno)
- {
- struct regcache *regcache;
- scoped_restore_current_thread restore_thread;
- switch_to_thread (get_lwp_thread (lwp));
- regcache = get_thread_regcache (current_thread, 1);
- low_get_syscall_trapinfo (regcache, sysno);
- threads_debug_printf ("get_syscall_trapinfo sysno %d", *sysno);
- }
- void
- linux_process_target::low_get_syscall_trapinfo (regcache *regcache, int *sysno)
- {
- /* By default, report an unknown system call number. */
- *sysno = UNKNOWN_SYSCALL;
- }
- bool
- linux_process_target::save_stop_reason (lwp_info *lwp)
- {
- CORE_ADDR pc;
- CORE_ADDR sw_breakpoint_pc;
- #if USE_SIGTRAP_SIGINFO
- siginfo_t siginfo;
- #endif
- if (!low_supports_breakpoints ())
- return false;
- pc = get_pc (lwp);
- sw_breakpoint_pc = pc - low_decr_pc_after_break ();
- /* breakpoint_at reads from the current thread. */
- scoped_restore_current_thread restore_thread;
- switch_to_thread (get_lwp_thread (lwp));
- #if USE_SIGTRAP_SIGINFO
- if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
- (PTRACE_TYPE_ARG3) 0, &siginfo) == 0)
- {
- if (siginfo.si_signo == SIGTRAP)
- {
- if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code)
- && GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
- {
- /* The si_code is ambiguous on this arch -- check debug
- registers. */
- if (!check_stopped_by_watchpoint (lwp))
- lwp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
- }
- else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code))
- {
- /* If we determine the LWP stopped for a SW breakpoint,
- trust it. Particularly don't check watchpoint
- registers, because at least on s390, we'd find
- stopped-by-watchpoint as long as there's a watchpoint
- set. */
- lwp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
- }
- else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
- {
- /* This can indicate either a hardware breakpoint or
- hardware watchpoint. Check debug registers. */
- if (!check_stopped_by_watchpoint (lwp))
- lwp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
- }
- else if (siginfo.si_code == TRAP_TRACE)
- {
- /* We may have single stepped an instruction that
- triggered a watchpoint. In that case, on some
- architectures (such as x86), instead of TRAP_HWBKPT,
- si_code indicates TRAP_TRACE, and we need to check
- the debug registers separately. */
- if (!check_stopped_by_watchpoint (lwp))
- lwp->stop_reason = TARGET_STOPPED_BY_SINGLE_STEP;
- }
- }
- }
- #else
- /* We may have just stepped a breakpoint instruction. E.g., in
- non-stop mode, GDB first tells the thread A to step a range, and
- then the user inserts a breakpoint inside the range. In that
- case we need to report the breakpoint PC. */
- if ((!lwp->stepping || lwp->stop_pc == sw_breakpoint_pc)
- && low_breakpoint_at (sw_breakpoint_pc))
- lwp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
- if (hardware_breakpoint_inserted_here (pc))
- lwp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
- if (lwp->stop_reason == TARGET_STOPPED_BY_NO_REASON)
- check_stopped_by_watchpoint (lwp);
- #endif
- if (lwp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
- {
- threads_debug_printf
- ("%s stopped by software breakpoint",
- target_pid_to_str (ptid_of (get_lwp_thread (lwp))).c_str ());
- /* Back up the PC if necessary. */
- if (pc != sw_breakpoint_pc)
- {
- struct regcache *regcache
- = get_thread_regcache (current_thread, 1);
- low_set_pc (regcache, sw_breakpoint_pc);
- }
- /* Update this so we record the correct stop PC below. */
- pc = sw_breakpoint_pc;
- }
- else if (lwp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
- threads_debug_printf
- ("%s stopped by hardware breakpoint",
- target_pid_to_str (ptid_of (get_lwp_thread (lwp))).c_str ());
- else if (lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
- threads_debug_printf
- ("%s stopped by hardware watchpoint",
- target_pid_to_str (ptid_of (get_lwp_thread (lwp))).c_str ());
- else if (lwp->stop_reason == TARGET_STOPPED_BY_SINGLE_STEP)
- threads_debug_printf
- ("%s stopped by trace",
- target_pid_to_str (ptid_of (get_lwp_thread (lwp))).c_str ());
- lwp->stop_pc = pc;
- return true;
- }
- lwp_info *
- linux_process_target::add_lwp (ptid_t ptid)
- {
- lwp_info *lwp = new lwp_info;
- lwp->thread = add_thread (ptid, lwp);
- low_new_thread (lwp);
- return lwp;
- }
- void
- linux_process_target::low_new_thread (lwp_info *info)
- {
- /* Nop. */
- }
- /* Callback to be used when calling fork_inferior, responsible for
- actually initiating the tracing of the inferior. */
- static void
- linux_ptrace_fun ()
- {
- if (ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) 0,
- (PTRACE_TYPE_ARG4) 0) < 0)
- trace_start_error_with_name ("ptrace");
- if (setpgid (0, 0) < 0)
- trace_start_error_with_name ("setpgid");
- /* If GDBserver is connected to gdb via stdio, redirect the inferior's
- stdout to stderr so that inferior i/o doesn't corrupt the connection.
- Also, redirect stdin to /dev/null. */
- if (remote_connection_is_stdio ())
- {
- if (close (0) < 0)
- trace_start_error_with_name ("close");
- if (open ("/dev/null", O_RDONLY) < 0)
- trace_start_error_with_name ("open");
- if (dup2 (2, 1) < 0)
- trace_start_error_with_name ("dup2");
- if (write (2, "stdin/stdout redirected\n",
- sizeof ("stdin/stdout redirected\n") - 1) < 0)
- {
- /* Errors ignored. */;
- }
- }
- }
- /* Start an inferior process and returns its pid.
- PROGRAM is the name of the program to be started, and PROGRAM_ARGS
- are its arguments. */
- int
- linux_process_target::create_inferior (const char *program,
- const std::vector<char *> &program_args)
- {
- client_state &cs = get_client_state ();
- struct lwp_info *new_lwp;
- int pid;
- ptid_t ptid;
- {
- maybe_disable_address_space_randomization restore_personality
- (cs.disable_randomization);
- std::string str_program_args = construct_inferior_arguments (program_args);
- pid = fork_inferior (program,
- str_program_args.c_str (),
- get_environ ()->envp (), linux_ptrace_fun,
- NULL, NULL, NULL, NULL);
- }
- add_linux_process (pid, 0);
- ptid = ptid_t (pid, pid);
- new_lwp = add_lwp (ptid);
- new_lwp->must_set_ptrace_flags = 1;
- post_fork_inferior (pid, program);
- return pid;
- }
- /* Implement the post_create_inferior target_ops method. */
- void
- linux_process_target::post_create_inferior ()
- {
- struct lwp_info *lwp = get_thread_lwp (current_thread);
- low_arch_setup ();
- if (lwp->must_set_ptrace_flags)
- {
- struct process_info *proc = current_process ();
- int options = linux_low_ptrace_options (proc->attached);
- linux_enable_event_reporting (lwpid_of (current_thread), options);
- lwp->must_set_ptrace_flags = 0;
- }
- }
- int
- linux_process_target::attach_lwp (ptid_t ptid)
- {
- struct lwp_info *new_lwp;
- int lwpid = ptid.lwp ();
- if (ptrace (PTRACE_ATTACH, lwpid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0)
- != 0)
- return errno;
- new_lwp = add_lwp (ptid);
- /* We need to wait for SIGSTOP before being able to make the next
- ptrace call on this LWP. */
- new_lwp->must_set_ptrace_flags = 1;
- if (linux_proc_pid_is_stopped (lwpid))
- {
- threads_debug_printf ("Attached to a stopped process");
- /* The process is definitely stopped. It is in a job control
- stop, unless the kernel predates the TASK_STOPPED /
- TASK_TRACED distinction, in which case it might be in a
- ptrace stop. Make sure it is in a ptrace stop; from there we
- can kill it, signal it, et cetera.
- First make sure there is a pending SIGSTOP. Since we are
- already attached, the process can not transition from stopped
- to running without a PTRACE_CONT; so we know this signal will
- go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
- probably already in the queue (unless this kernel is old
- enough to use TASK_STOPPED for ptrace stops); but since
- SIGSTOP is not an RT signal, it can only be queued once. */
- kill_lwp (lwpid, SIGSTOP);
- /* Finally, resume the stopped process. This will deliver the
- SIGSTOP (or a higher priority signal, just like normal
- PTRACE_ATTACH), which we'll catch later on. */
- ptrace (PTRACE_CONT, lwpid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
- }
- /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
- brings it to a halt.
- There are several cases to consider here:
- 1) gdbserver has already attached to the process and is being notified
- of a new thread that is being created.
- In this case we should ignore that SIGSTOP and resume the
- process. This is handled below by setting stop_expected = 1,
- and the fact that add_thread sets last_resume_kind ==
- resume_continue.
- 2) This is the first thread (the process thread), and we're attaching
- to it via attach_inferior.
- In this case we want the process thread to stop.
- This is handled by having linux_attach set last_resume_kind ==
- resume_stop after we return.
- If the pid we are attaching to is also the tgid, we attach to and
- stop all the existing threads. Otherwise, we attach to pid and
- ignore any other threads in the same group as this pid.
- 3) GDB is connecting to gdbserver and is requesting an enumeration of all
- existing threads.
- In this case we want the thread to stop.
- FIXME: This case is currently not properly handled.
- We should wait for the SIGSTOP but don't. Things work apparently
- because enough time passes between when we ptrace (ATTACH) and when
- gdb makes the next ptrace call on the thread.
- On the other hand, if we are currently trying to stop all threads, we
- should treat the new thread as if we had sent it a SIGSTOP. This works
- because we are guaranteed that the add_lwp call above added us to the
- end of the list, and so the new thread has not yet reached
- wait_for_sigstop (but will). */
- new_lwp->stop_expected = 1;
- return 0;
- }
- /* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
- already attached. Returns true if a new LWP is found, false
- otherwise. */
- static int
- attach_proc_task_lwp_callback (ptid_t ptid)
- {
- /* Is this a new thread? */
- if (find_thread_ptid (ptid) == NULL)
- {
- int lwpid = ptid.lwp ();
- int err;
- threads_debug_printf ("Found new lwp %d", lwpid);
- err = the_linux_target->attach_lwp (ptid);
- /* Be quiet if we simply raced with the thread exiting. EPERM
- is returned if the thread's task still exists, and is marked
- as exited or zombie, as well as other conditions, so in that
- case, confirm the status in /proc/PID/status. */
- if (err == ESRCH
- || (err == EPERM && linux_proc_pid_is_gone (lwpid)))
- threads_debug_printf
- ("Cannot attach to lwp %d: thread is gone (%d: %s)",
- lwpid, err, safe_strerror (err));
- else if (err != 0)
- {
- std::string reason
- = linux_ptrace_attach_fail_reason_string (ptid, err);
- warning (_("Cannot attach to lwp %d: %s"), lwpid, reason.c_str ());
- }
- return 1;
- }
- return 0;
- }
- static void async_file_mark (void);
- /* Attach to PID. If PID is the tgid, attach to it and all
- of its threads. */
- int
- linux_process_target::attach (unsigned long pid)
- {
- struct process_info *proc;
- struct thread_info *initial_thread;
- ptid_t ptid = ptid_t (pid, pid);
- int err;
- proc = add_linux_process (pid, 1);
- /* Attach to PID. We will check for other threads
- soon. */
- err = attach_lwp (ptid);
- if (err != 0)
- {
- remove_process (proc);
- std::string reason = linux_ptrace_attach_fail_reason_string (ptid, err);
- error ("Cannot attach to process %ld: %s", pid, reason.c_str ());
- }
- /* Don't ignore the initial SIGSTOP if we just attached to this
- process. It will be collected by wait shortly. */
- initial_thread = find_thread_ptid (ptid_t (pid, pid));
- initial_thread->last_resume_kind = resume_stop;
- /* We must attach to every LWP. If /proc is mounted, use that to
- find them now. On the one hand, the inferior may be using raw
- clone instead of using pthreads. On the other hand, even if it
- is using pthreads, GDB may not be connected yet (thread_db needs
- to do symbol lookups, through qSymbol). Also, thread_db walks
- structures in the inferior's address space to find the list of
- threads/LWPs, and those structures may well be corrupted. Note
- that once thread_db is loaded, we'll still use it to list threads
- and associate pthread info with each LWP. */
- linux_proc_attach_tgid_threads (pid, attach_proc_task_lwp_callback);
- /* GDB will shortly read the xml target description for this
- process, to figure out the process' architecture. But the target
- description is only filled in when the first process/thread in
- the thread group reports its initial PTRACE_ATTACH SIGSTOP. Do
- that now, otherwise, if GDB is fast enough, it could read the
- target description _before_ that initial stop. */
- if (non_stop)
- {
- struct lwp_info *lwp;
- int wstat, lwpid;
- ptid_t pid_ptid = ptid_t (pid);
- lwpid = wait_for_event_filtered (pid_ptid, pid_ptid, &wstat, __WALL);
- gdb_assert (lwpid > 0);
- lwp = find_lwp_pid (ptid_t (lwpid));
- if (!WIFSTOPPED (wstat) || WSTOPSIG (wstat) != SIGSTOP)
- {
- lwp->status_pending_p = 1;
- lwp->status_pending = wstat;
- }
- initial_thread->last_resume_kind = resume_continue;
- async_file_mark ();
- gdb_assert (proc->tdesc != NULL);
- }
- return 0;
- }
- static int
- last_thread_of_process_p (int pid)
- {
- bool seen_one = false;
- thread_info *thread = find_thread (pid, [&] (thread_info *thr_arg)
- {
- if (!seen_one)
- {
- /* This is the first thread of this process we see. */
- seen_one = true;
- return false;
- }
- else
- {
- /* This is the second thread of this process we see. */
- return true;
- }
- });
- return thread == NULL;
- }
- /* Kill LWP. */
- static void
- linux_kill_one_lwp (struct lwp_info *lwp)
- {
- struct thread_info *thr = get_lwp_thread (lwp);
- int pid = lwpid_of (thr);
- /* PTRACE_KILL is unreliable. After stepping into a signal handler,
- there is no signal context, and ptrace(PTRACE_KILL) (or
- ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
- ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
- alternative is to kill with SIGKILL. We only need one SIGKILL
- per process, not one for each thread. But since we still support
- support debugging programs using raw clone without CLONE_THREAD,
- we send one for each thread. For years, we used PTRACE_KILL
- only, so we're being a bit paranoid about some old kernels where
- PTRACE_KILL might work better (dubious if there are any such, but
- that's why it's paranoia), so we try SIGKILL first, PTRACE_KILL
- second, and so we're fine everywhere. */
- errno = 0;
- kill_lwp (pid, SIGKILL);
- if (debug_threads)
- {
- int save_errno = errno;
- threads_debug_printf ("kill_lwp (SIGKILL) %s, 0, 0 (%s)",
- target_pid_to_str (ptid_of (thr)).c_str (),
- save_errno ? safe_strerror (save_errno) : "OK");
- }
- errno = 0;
- ptrace (PTRACE_KILL, pid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
- if (debug_threads)
- {
- int save_errno = errno;
- threads_debug_printf ("PTRACE_KILL %s, 0, 0 (%s)",
- target_pid_to_str (ptid_of (thr)).c_str (),
- save_errno ? safe_strerror (save_errno) : "OK");
- }
- }
- /* Kill LWP and wait for it to die. */
- static void
- kill_wait_lwp (struct lwp_info *lwp)
- {
- struct thread_info *thr = get_lwp_thread (lwp);
- int pid = ptid_of (thr).pid ();
- int lwpid = ptid_of (thr).lwp ();
- int wstat;
- int res;
- threads_debug_printf ("killing lwp %d, for pid: %d", lwpid, pid);
- do
- {
- linux_kill_one_lwp (lwp);
- /* Make sure it died. Notes:
- - The loop is most likely unnecessary.
- - We don't use wait_for_event as that could delete lwps
- while we're iterating over them. We're not interested in
- any pending status at this point, only in making sure all
- wait status on the kernel side are collected until the
- process is reaped.
- - We don't use __WALL here as the __WALL emulation relies on
- SIGCHLD, and killing a stopped process doesn't generate
- one, nor an exit status.
- */
- res = my_waitpid (lwpid, &wstat, 0);
- if (res == -1 && errno == ECHILD)
- res = my_waitpid (lwpid, &wstat, __WCLONE);
- } while (res > 0 && WIFSTOPPED (wstat));
- /* Even if it was stopped, the child may have already disappeared.
- E.g., if it was killed by SIGKILL. */
- if (res < 0 && errno != ECHILD)
- perror_with_name ("kill_wait_lwp");
- }
- /* Callback for `for_each_thread'. Kills an lwp of a given process,
- except the leader. */
- static void
- kill_one_lwp_callback (thread_info *thread, int pid)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- /* We avoid killing the first thread here, because of a Linux kernel (at
- least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
- the children get a chance to be reaped, it will remain a zombie
- forever. */
- if (lwpid_of (thread) == pid)
- {
- threads_debug_printf ("is last of process %s",
- target_pid_to_str (thread->id).c_str ());
- return;
- }
- kill_wait_lwp (lwp);
- }
- int
- linux_process_target::kill (process_info *process)
- {
- int pid = process->pid;
- /* If we're killing a running inferior, make sure it is stopped
- first, as PTRACE_KILL will not work otherwise. */
- stop_all_lwps (0, NULL);
- for_each_thread (pid, [&] (thread_info *thread)
- {
- kill_one_lwp_callback (thread, pid);
- });
- /* See the comment in linux_kill_one_lwp. We did not kill the first
- thread in the list, so do so now. */
- lwp_info *lwp = find_lwp_pid (ptid_t (pid));
- if (lwp == NULL)
- threads_debug_printf ("cannot find lwp for pid: %d", pid);
- else
- kill_wait_lwp (lwp);
- mourn (process);
- /* Since we presently can only stop all lwps of all processes, we
- need to unstop lwps of other processes. */
- unstop_all_lwps (0, NULL);
- return 0;
- }
- /* Get pending signal of THREAD, for detaching purposes. This is the
- signal the thread last stopped for, which we need to deliver to the
- thread when detaching, otherwise, it'd be suppressed/lost. */
- static int
- get_detach_signal (struct thread_info *thread)
- {
- client_state &cs = get_client_state ();
- enum gdb_signal signo = GDB_SIGNAL_0;
- int status;
- struct lwp_info *lp = get_thread_lwp (thread);
- if (lp->status_pending_p)
- status = lp->status_pending;
- else
- {
- /* If the thread had been suspended by gdbserver, and it stopped
- cleanly, then it'll have stopped with SIGSTOP. But we don't
- want to deliver that SIGSTOP. */
- if (thread->last_status.kind () != TARGET_WAITKIND_STOPPED
- || thread->last_status.sig () == GDB_SIGNAL_0)
- return 0;
- /* Otherwise, we may need to deliver the signal we
- intercepted. */
- status = lp->last_status;
- }
- if (!WIFSTOPPED (status))
- {
- threads_debug_printf ("lwp %s hasn't stopped: no pending signal",
- target_pid_to_str (ptid_of (thread)).c_str ());
- return 0;
- }
- /* Extended wait statuses aren't real SIGTRAPs. */
- if (WSTOPSIG (status) == SIGTRAP && linux_is_extended_waitstatus (status))
- {
- threads_debug_printf ("lwp %s had stopped with extended "
- "status: no pending signal",
- target_pid_to_str (ptid_of (thread)).c_str ());
- return 0;
- }
- signo = gdb_signal_from_host (WSTOPSIG (status));
- if (cs.program_signals_p && !cs.program_signals[signo])
- {
- threads_debug_printf ("lwp %s had signal %s, but it is in nopass state",
- target_pid_to_str (ptid_of (thread)).c_str (),
- gdb_signal_to_string (signo));
- return 0;
- }
- else if (!cs.program_signals_p
- /* If we have no way to know which signals GDB does not
- want to have passed to the program, assume
- SIGTRAP/SIGINT, which is GDB's default. */
- && (signo == GDB_SIGNAL_TRAP || signo == GDB_SIGNAL_INT))
- {
- threads_debug_printf ("lwp %s had signal %s, "
- "but we don't know if we should pass it. "
- "Default to not.",
- target_pid_to_str (ptid_of (thread)).c_str (),
- gdb_signal_to_string (signo));
- return 0;
- }
- else
- {
- threads_debug_printf ("lwp %s has pending signal %s: delivering it",
- target_pid_to_str (ptid_of (thread)).c_str (),
- gdb_signal_to_string (signo));
- return WSTOPSIG (status);
- }
- }
- void
- linux_process_target::detach_one_lwp (lwp_info *lwp)
- {
- struct thread_info *thread = get_lwp_thread (lwp);
- int sig;
- int lwpid;
- /* If there is a pending SIGSTOP, get rid of it. */
- if (lwp->stop_expected)
- {
- threads_debug_printf ("Sending SIGCONT to %s",
- target_pid_to_str (ptid_of (thread)).c_str ());
- kill_lwp (lwpid_of (thread), SIGCONT);
- lwp->stop_expected = 0;
- }
- /* Pass on any pending signal for this thread. */
- sig = get_detach_signal (thread);
- /* Preparing to resume may try to write registers, and fail if the
- lwp is zombie. If that happens, ignore the error. We'll handle
- it below, when detach fails with ESRCH. */
- try
- {
- /* Flush any pending changes to the process's registers. */
- regcache_invalidate_thread (thread);
- /* Finally, let it resume. */
- low_prepare_to_resume (lwp);
- }
- catch (const gdb_exception_error &ex)
- {
- if (!check_ptrace_stopped_lwp_gone (lwp))
- throw;
- }
- lwpid = lwpid_of (thread);
- if (ptrace (PTRACE_DETACH, lwpid, (PTRACE_TYPE_ARG3) 0,
- (PTRACE_TYPE_ARG4) (long) sig) < 0)
- {
- int save_errno = errno;
- /* We know the thread exists, so ESRCH must mean the lwp is
- zombie. This can happen if one of the already-detached
- threads exits the whole thread group. In that case we're
- still attached, and must reap the lwp. */
- if (save_errno == ESRCH)
- {
- int ret, status;
- ret = my_waitpid (lwpid, &status, __WALL);
- if (ret == -1)
- {
- warning (_("Couldn't reap LWP %d while detaching: %s"),
- lwpid, safe_strerror (errno));
- }
- else if (!WIFEXITED (status) && !WIFSIGNALED (status))
- {
- warning (_("Reaping LWP %d while detaching "
- "returned unexpected status 0x%x"),
- lwpid, status);
- }
- }
- else
- {
- error (_("Can't detach %s: %s"),
- target_pid_to_str (ptid_of (thread)).c_str (),
- safe_strerror (save_errno));
- }
- }
- else
- threads_debug_printf ("PTRACE_DETACH (%s, %s, 0) (OK)",
- target_pid_to_str (ptid_of (thread)).c_str (),
- strsignal (sig));
- delete_lwp (lwp);
- }
- int
- linux_process_target::detach (process_info *process)
- {
- struct lwp_info *main_lwp;
- /* As there's a step over already in progress, let it finish first,
- otherwise nesting a stabilize_threads operation on top gets real
- messy. */
- complete_ongoing_step_over ();
- /* Stop all threads before detaching. First, ptrace requires that
- the thread is stopped to successfully detach. Second, thread_db
- may need to uninstall thread event breakpoints from memory, which
- only works with a stopped process anyway. */
- stop_all_lwps (0, NULL);
- #ifdef USE_THREAD_DB
- thread_db_detach (process);
- #endif
- /* Stabilize threads (move out of jump pads). */
- target_stabilize_threads ();
- /* Detach from the clone lwps first. If the thread group exits just
- while we're detaching, we must reap the clone lwps before we're
- able to reap the leader. */
- for_each_thread (process->pid, [this] (thread_info *thread)
- {
- /* We don't actually detach from the thread group leader just yet.
- If the thread group exits, we must reap the zombie clone lwps
- before we're able to reap the leader. */
- if (thread->id.pid () == thread->id.lwp ())
- return;
- lwp_info *lwp = get_thread_lwp (thread);
- detach_one_lwp (lwp);
- });
- main_lwp = find_lwp_pid (ptid_t (process->pid));
- detach_one_lwp (main_lwp);
- mourn (process);
- /* Since we presently can only stop all lwps of all processes, we
- need to unstop lwps of other processes. */
- unstop_all_lwps (0, NULL);
- return 0;
- }
- /* Remove all LWPs that belong to process PROC from the lwp list. */
- void
- linux_process_target::mourn (process_info *process)
- {
- struct process_info_private *priv;
- #ifdef USE_THREAD_DB
- thread_db_mourn (process);
- #endif
- for_each_thread (process->pid, [this] (thread_info *thread)
- {
- delete_lwp (get_thread_lwp (thread));
- });
- /* Freeing all private data. */
- priv = process->priv;
- low_delete_process (priv->arch_private);
- free (priv);
- process->priv = NULL;
- remove_process (process);
- }
- void
- linux_process_target::join (int pid)
- {
- int status, ret;
- do {
- ret = my_waitpid (pid, &status, 0);
- if (WIFEXITED (status) || WIFSIGNALED (status))
- break;
- } while (ret != -1 || errno != ECHILD);
- }
- /* Return true if the given thread is still alive. */
- bool
- linux_process_target::thread_alive (ptid_t ptid)
- {
- struct lwp_info *lwp = find_lwp_pid (ptid);
- /* We assume we always know if a thread exits. If a whole process
- exited but we still haven't been able to report it to GDB, we'll
- hold on to the last lwp of the dead process. */
- if (lwp != NULL)
- return !lwp_is_marked_dead (lwp);
- else
- return 0;
- }
- bool
- linux_process_target::thread_still_has_status_pending (thread_info *thread)
- {
- struct lwp_info *lp = get_thread_lwp (thread);
- if (!lp->status_pending_p)
- return 0;
- if (thread->last_resume_kind != resume_stop
- && (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
- || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
- {
- CORE_ADDR pc;
- int discard = 0;
- gdb_assert (lp->last_status != 0);
- pc = get_pc (lp);
- scoped_restore_current_thread restore_thread;
- switch_to_thread (thread);
- if (pc != lp->stop_pc)
- {
- threads_debug_printf ("PC of %ld changed",
- lwpid_of (thread));
- discard = 1;
- }
- #if !USE_SIGTRAP_SIGINFO
- else if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
- && !low_breakpoint_at (pc))
- {
- threads_debug_printf ("previous SW breakpoint of %ld gone",
- lwpid_of (thread));
- discard = 1;
- }
- else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT
- && !hardware_breakpoint_inserted_here (pc))
- {
- threads_debug_printf ("previous HW breakpoint of %ld gone",
- lwpid_of (thread));
- discard = 1;
- }
- #endif
- if (discard)
- {
- threads_debug_printf ("discarding pending breakpoint status");
- lp->status_pending_p = 0;
- return 0;
- }
- }
- return 1;
- }
- /* Returns true if LWP is resumed from the client's perspective. */
- static int
- lwp_resumed (struct lwp_info *lwp)
- {
- struct thread_info *thread = get_lwp_thread (lwp);
- if (thread->last_resume_kind != resume_stop)
- return 1;
- /* Did gdb send us a `vCont;t', but we haven't reported the
- corresponding stop to gdb yet? If so, the thread is still
- resumed/running from gdb's perspective. */
- if (thread->last_resume_kind == resume_stop
- && thread->last_status.kind () == TARGET_WAITKIND_IGNORE)
- return 1;
- return 0;
- }
- bool
- linux_process_target::status_pending_p_callback (thread_info *thread,
- ptid_t ptid)
- {
- struct lwp_info *lp = get_thread_lwp (thread);
- /* Check if we're only interested in events from a specific process
- or a specific LWP. */
- if (!thread->id.matches (ptid))
- return 0;
- if (!lwp_resumed (lp))
- return 0;
- if (lp->status_pending_p
- && !thread_still_has_status_pending (thread))
- {
- resume_one_lwp (lp, lp->stepping, GDB_SIGNAL_0, NULL);
- return 0;
- }
- return lp->status_pending_p;
- }
- struct lwp_info *
- find_lwp_pid (ptid_t ptid)
- {
- thread_info *thread = find_thread ([&] (thread_info *thr_arg)
- {
- int lwp = ptid.lwp () != 0 ? ptid.lwp () : ptid.pid ();
- return thr_arg->id.lwp () == lwp;
- });
- if (thread == NULL)
- return NULL;
- return get_thread_lwp (thread);
- }
- /* Return the number of known LWPs in the tgid given by PID. */
- static int
- num_lwps (int pid)
- {
- int count = 0;
- for_each_thread (pid, [&] (thread_info *thread)
- {
- count++;
- });
- return count;
- }
- /* See nat/linux-nat.h. */
- struct lwp_info *
- iterate_over_lwps (ptid_t filter,
- gdb::function_view<iterate_over_lwps_ftype> callback)
- {
- thread_info *thread = find_thread (filter, [&] (thread_info *thr_arg)
- {
- lwp_info *lwp = get_thread_lwp (thr_arg);
- return callback (lwp);
- });
- if (thread == NULL)
- return NULL;
- return get_thread_lwp (thread);
- }
- void
- linux_process_target::check_zombie_leaders ()
- {
- for_each_process ([this] (process_info *proc)
- {
- pid_t leader_pid = pid_of (proc);
- lwp_info *leader_lp = find_lwp_pid (ptid_t (leader_pid));
- threads_debug_printf ("leader_pid=%d, leader_lp!=NULL=%d, "
- "num_lwps=%d, zombie=%d",
- leader_pid, leader_lp!= NULL, num_lwps (leader_pid),
- linux_proc_pid_is_zombie (leader_pid));
- if (leader_lp != NULL && !leader_lp->stopped
- /* Check if there are other threads in the group, as we may
- have raced with the inferior simply exiting. Note this
- isn't a watertight check. If the inferior is
- multi-threaded and is exiting, it may be we see the
- leader as zombie before we reap all the non-leader
- threads. See comments below. */
- && !last_thread_of_process_p (leader_pid)
- && linux_proc_pid_is_zombie (leader_pid))
- {
- /* A zombie leader in a multi-threaded program can mean one
- of three things:
- #1 - Only the leader exited, not the whole program, e.g.,
- with pthread_exit. Since we can't reap the leader's exit
- status until all other threads are gone and reaped too,
- we want to delete the zombie leader right away, as it
- can't be debugged, we can't read its registers, etc.
- This is the main reason we check for zombie leaders
- disappearing.
- #2 - The whole thread-group/process exited (a group exit,
- via e.g. exit(3), and there is (or will be shortly) an
- exit reported for each thread in the process, and then
- finally an exit for the leader once the non-leaders are
- reaped.
- #3 - There are 3 or more threads in the group, and a
- thread other than the leader exec'd. See comments on
- exec events at the top of the file.
- Ideally we would never delete the leader for case #2.
- Instead, we want to collect the exit status of each
- non-leader thread, and then finally collect the exit
- status of the leader as normal and use its exit code as
- whole-process exit code. Unfortunately, there's no
- race-free way to distinguish cases #1 and #2. We can't
- assume the exit events for the non-leaders threads are
- already pending in the kernel, nor can we assume the
- non-leader threads are in zombie state already. Between
- the leader becoming zombie and the non-leaders exiting
- and becoming zombie themselves, there's a small time
- window, so such a check would be racy. Temporarily
- pausing all threads and checking to see if all threads
- exit or not before re-resuming them would work in the
- case that all threads are running right now, but it
- wouldn't work if some thread is currently already
- ptrace-stopped, e.g., due to scheduler-locking.
- So what we do is we delete the leader anyhow, and then
- later on when we see its exit status, we re-add it back.
- We also make sure that we only report a whole-process
- exit when we see the leader exiting, as opposed to when
- the last LWP in the LWP list exits, which can be a
- non-leader if we deleted the leader here. */
- threads_debug_printf ("Thread group leader %d zombie "
- "(it exited, or another thread execd), "
- "deleting it.",
- leader_pid);
- delete_lwp (leader_lp);
- }
- });
- }
- /* Callback for `find_thread'. Returns the first LWP that is not
- stopped. */
- static bool
- not_stopped_callback (thread_info *thread, ptid_t filter)
- {
- if (!thread->id.matches (filter))
- return false;
- lwp_info *lwp = get_thread_lwp (thread);
- return !lwp->stopped;
- }
- /* Increment LWP's suspend count. */
- static void
- lwp_suspended_inc (struct lwp_info *lwp)
- {
- lwp->suspended++;
- if (lwp->suspended > 4)
- threads_debug_printf
- ("LWP %ld has a suspiciously high suspend count, suspended=%d",
- lwpid_of (get_lwp_thread (lwp)), lwp->suspended);
- }
- /* Decrement LWP's suspend count. */
- static void
- lwp_suspended_decr (struct lwp_info *lwp)
- {
- lwp->suspended--;
- if (lwp->suspended < 0)
- {
- struct thread_info *thread = get_lwp_thread (lwp);
- internal_error (__FILE__, __LINE__,
- "unsuspend LWP %ld, suspended=%d\n", lwpid_of (thread),
- lwp->suspended);
- }
- }
- /* This function should only be called if the LWP got a SIGTRAP.
- Handle any tracepoint steps or hits. Return true if a tracepoint
- event was handled, 0 otherwise. */
- static int
- handle_tracepoints (struct lwp_info *lwp)
- {
- struct thread_info *tinfo = get_lwp_thread (lwp);
- int tpoint_related_event = 0;
- gdb_assert (lwp->suspended == 0);
- /* If this tracepoint hit causes a tracing stop, we'll immediately
- uninsert tracepoints. To do this, we temporarily pause all
- threads, unpatch away, and then unpause threads. We need to make
- sure the unpausing doesn't resume LWP too. */
- lwp_suspended_inc (lwp);
- /* And we need to be sure that any all-threads-stopping doesn't try
- to move threads out of the jump pads, as it could deadlock the
- inferior (LWP could be in the jump pad, maybe even holding the
- lock.) */
- /* Do any necessary step collect actions. */
- tpoint_related_event |= tracepoint_finished_step (tinfo, lwp->stop_pc);
- tpoint_related_event |= handle_tracepoint_bkpts (tinfo, lwp->stop_pc);
- /* See if we just hit a tracepoint and do its main collect
- actions. */
- tpoint_related_event |= tracepoint_was_hit (tinfo, lwp->stop_pc);
- lwp_suspended_decr (lwp);
- gdb_assert (lwp->suspended == 0);
- gdb_assert (!stabilizing_threads
- || (lwp->collecting_fast_tracepoint
- != fast_tpoint_collect_result::not_collecting));
- if (tpoint_related_event)
- {
- threads_debug_printf ("got a tracepoint event");
- return 1;
- }
- return 0;
- }
- fast_tpoint_collect_result
- linux_process_target::linux_fast_tracepoint_collecting
- (lwp_info *lwp, fast_tpoint_collect_status *status)
- {
- CORE_ADDR thread_area;
- struct thread_info *thread = get_lwp_thread (lwp);
- /* Get the thread area address. This is used to recognize which
- thread is which when tracing with the in-process agent library.
- We don't read anything from the address, and treat it as opaque;
- it's the address itself that we assume is unique per-thread. */
- if (low_get_thread_area (lwpid_of (thread), &thread_area) == -1)
- return fast_tpoint_collect_result::not_collecting;
- return fast_tracepoint_collecting (thread_area, lwp->stop_pc, status);
- }
- int
- linux_process_target::low_get_thread_area (int lwpid, CORE_ADDR *addrp)
- {
- return -1;
- }
- bool
- linux_process_target::maybe_move_out_of_jump_pad (lwp_info *lwp, int *wstat)
- {
- scoped_restore_current_thread restore_thread;
- switch_to_thread (get_lwp_thread (lwp));
- if ((wstat == NULL
- || (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) != SIGTRAP))
- && supports_fast_tracepoints ()
- && agent_loaded_p ())
- {
- struct fast_tpoint_collect_status status;
- threads_debug_printf
- ("Checking whether LWP %ld needs to move out of the jump pad.",
- lwpid_of (current_thread));
- fast_tpoint_collect_result r
- = linux_fast_tracepoint_collecting (lwp, &status);
- if (wstat == NULL
- || (WSTOPSIG (*wstat) != SIGILL
- && WSTOPSIG (*wstat) != SIGFPE
- && WSTOPSIG (*wstat) != SIGSEGV
- && WSTOPSIG (*wstat) != SIGBUS))
- {
- lwp->collecting_fast_tracepoint = r;
- if (r != fast_tpoint_collect_result::not_collecting)
- {
- if (r == fast_tpoint_collect_result::before_insn
- && lwp->exit_jump_pad_bkpt == NULL)
- {
- /* Haven't executed the original instruction yet.
- Set breakpoint there, and wait till it's hit,
- then single-step until exiting the jump pad. */
- lwp->exit_jump_pad_bkpt
- = set_breakpoint_at (status.adjusted_insn_addr, NULL);
- }
- threads_debug_printf
- ("Checking whether LWP %ld needs to move out of the jump pad..."
- " it does", lwpid_of (current_thread));
- return true;
- }
- }
- else
- {
- /* If we get a synchronous signal while collecting, *and*
- while executing the (relocated) original instruction,
- reset the PC to point at the tpoint address, before
- reporting to GDB. Otherwise, it's an IPA lib bug: just
- report the signal to GDB, and pray for the best. */
- lwp->collecting_fast_tracepoint
- = fast_tpoint_collect_result::not_collecting;
- if (r != fast_tpoint_collect_result::not_collecting
- && (status.adjusted_insn_addr <= lwp->stop_pc
- && lwp->stop_pc < status.adjusted_insn_addr_end))
- {
- siginfo_t info;
- struct regcache *regcache;
- /* The si_addr on a few signals references the address
- of the faulting instruction. Adjust that as
- well. */
- if ((WSTOPSIG (*wstat) == SIGILL
- || WSTOPSIG (*wstat) == SIGFPE
- || WSTOPSIG (*wstat) == SIGBUS
- || WSTOPSIG (*wstat) == SIGSEGV)
- && ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
- (PTRACE_TYPE_ARG3) 0, &info) == 0
- /* Final check just to make sure we don't clobber
- the siginfo of non-kernel-sent signals. */
- && (uintptr_t) info.si_addr == lwp->stop_pc)
- {
- info.si_addr = (void *) (uintptr_t) status.tpoint_addr;
- ptrace (PTRACE_SETSIGINFO, lwpid_of (current_thread),
- (PTRACE_TYPE_ARG3) 0, &info);
- }
- regcache = get_thread_regcache (current_thread, 1);
- low_set_pc (regcache, status.tpoint_addr);
- lwp->stop_pc = status.tpoint_addr;
- /* Cancel any fast tracepoint lock this thread was
- holding. */
- force_unlock_trace_buffer ();
- }
- if (lwp->exit_jump_pad_bkpt != NULL)
- {
- threads_debug_printf
- ("Cancelling fast exit-jump-pad: removing bkpt."
- "stopping all threads momentarily.");
- stop_all_lwps (1, lwp);
- delete_breakpoint (lwp->exit_jump_pad_bkpt);
- lwp->exit_jump_pad_bkpt = NULL;
- unstop_all_lwps (1, lwp);
- gdb_assert (lwp->suspended >= 0);
- }
- }
- }
- threads_debug_printf
- ("Checking whether LWP %ld needs to move out of the jump pad... no",
- lwpid_of (current_thread));
- return false;
- }
- /* Enqueue one signal in the "signals to report later when out of the
- jump pad" list. */
- static void
- enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
- {
- struct thread_info *thread = get_lwp_thread (lwp);
- threads_debug_printf ("Deferring signal %d for LWP %ld.",
- WSTOPSIG (*wstat), lwpid_of (thread));
- if (debug_threads)
- {
- for (const auto &sig : lwp->pending_signals_to_report)
- threads_debug_printf (" Already queued %d", sig.signal);
- threads_debug_printf (" (no more currently queued signals)");
- }
- /* Don't enqueue non-RT signals if they are already in the deferred
- queue. (SIGSTOP being the easiest signal to see ending up here
- twice) */
- if (WSTOPSIG (*wstat) < __SIGRTMIN)
- {
- for (const auto &sig : lwp->pending_signals_to_report)
- {
- if (sig.signal == WSTOPSIG (*wstat))
- {
- threads_debug_printf
- ("Not requeuing already queued non-RT signal %d for LWP %ld",
- sig.signal, lwpid_of (thread));
- return;
- }
- }
- }
- lwp->pending_signals_to_report.emplace_back (WSTOPSIG (*wstat));
- ptrace (PTRACE_GETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
- &lwp->pending_signals_to_report.back ().info);
- }
- /* Dequeue one signal from the "signals to report later when out of
- the jump pad" list. */
- static int
- dequeue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
- {
- struct thread_info *thread = get_lwp_thread (lwp);
- if (!lwp->pending_signals_to_report.empty ())
- {
- const pending_signal &p_sig = lwp->pending_signals_to_report.front ();
- *wstat = W_STOPCODE (p_sig.signal);
- if (p_sig.info.si_signo != 0)
- ptrace (PTRACE_SETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
- &p_sig.info);
- lwp->pending_signals_to_report.pop_front ();
- threads_debug_printf ("Reporting deferred signal %d for LWP %ld.",
- WSTOPSIG (*wstat), lwpid_of (thread));
- if (debug_threads)
- {
- for (const auto &sig : lwp->pending_signals_to_report)
- threads_debug_printf (" Still queued %d", sig.signal);
- threads_debug_printf (" (no more queued signals)");
- }
- return 1;
- }
- return 0;
- }
- bool
- linux_process_target::check_stopped_by_watchpoint (lwp_info *child)
- {
- scoped_restore_current_thread restore_thread;
- switch_to_thread (get_lwp_thread (child));
- if (low_stopped_by_watchpoint ())
- {
- child->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
- child->stopped_data_address = low_stopped_data_address ();
- }
- return child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
- }
- bool
- linux_process_target::low_stopped_by_watchpoint ()
- {
- return false;
- }
- CORE_ADDR
- linux_process_target::low_stopped_data_address ()
- {
- return 0;
- }
- /* Return the ptrace options that we want to try to enable. */
- static int
- linux_low_ptrace_options (int attached)
- {
- client_state &cs = get_client_state ();
- int options = 0;
- if (!attached)
- options |= PTRACE_O_EXITKILL;
- if (cs.report_fork_events)
- options |= PTRACE_O_TRACEFORK;
- if (cs.report_vfork_events)
- options |= (PTRACE_O_TRACEVFORK | PTRACE_O_TRACEVFORKDONE);
- if (cs.report_exec_events)
- options |= PTRACE_O_TRACEEXEC;
- options |= PTRACE_O_TRACESYSGOOD;
- return options;
- }
- void
- linux_process_target::filter_event (int lwpid, int wstat)
- {
- client_state &cs = get_client_state ();
- struct lwp_info *child;
- struct thread_info *thread;
- int have_stop_pc = 0;
- child = find_lwp_pid (ptid_t (lwpid));
- /* Check for events reported by anything not in our LWP list. */
- if (child == nullptr)
- {
- if (WIFSTOPPED (wstat))
- {
- if (WSTOPSIG (wstat) == SIGTRAP
- && linux_ptrace_get_extended_event (wstat) == PTRACE_EVENT_EXEC)
- {
- /* A non-leader thread exec'ed after we've seen the
- leader zombie, and removed it from our lists (in
- check_zombie_leaders). The non-leader thread changes
- its tid to the tgid. */
- threads_debug_printf
- ("Re-adding thread group leader LWP %d after exec.",
- lwpid);
- child = add_lwp (ptid_t (lwpid, lwpid));
- child->stopped = 1;
- switch_to_thread (child->thread);
- }
- else
- {
- /* A process we are controlling has forked and the new
- child's stop was reported to us by the kernel. Save
- its PID and go back to waiting for the fork event to
- be reported - the stopped process might be returned
- from waitpid before or after the fork event is. */
- threads_debug_printf
- ("Saving LWP %d status %s in stopped_pids list",
- lwpid, status_to_str (wstat).c_str ());
- add_to_pid_list (&stopped_pids, lwpid, wstat);
- }
- }
- else
- {
- /* Don't report an event for the exit of an LWP not in our
- list, i.e. not part of any inferior we're debugging.
- This can happen if we detach from a program we originally
- forked and then it exits. However, note that we may have
- earlier deleted a leader of an inferior we're debugging,
- in check_zombie_leaders. Re-add it back here if so. */
- find_process ([&] (process_info *proc)
- {
- if (proc->pid == lwpid)
- {
- threads_debug_printf
- ("Re-adding thread group leader LWP %d after exit.",
- lwpid);
- child = add_lwp (ptid_t (lwpid, lwpid));
- return true;
- }
- return false;
- });
- }
- if (child == nullptr)
- return;
- }
- thread = get_lwp_thread (child);
- child->stopped = 1;
- child->last_status = wstat;
- /* Check if the thread has exited. */
- if ((WIFEXITED (wstat) || WIFSIGNALED (wstat)))
- {
- threads_debug_printf ("%d exited", lwpid);
- if (finish_step_over (child))
- {
- /* Unsuspend all other LWPs, and set them back running again. */
- unsuspend_all_lwps (child);
- }
- /* If this is not the leader LWP, then the exit signal was not
- the end of the debugged application and should be ignored,
- unless GDB wants to hear about thread exits. */
- if (cs.report_thread_events || is_leader (thread))
- {
- /* Since events are serialized to GDB core, and we can't
- report this one right now. Leave the status pending for
- the next time we're able to report it. */
- mark_lwp_dead (child, wstat);
- return;
- }
- else
- {
- delete_lwp (child);
- return;
- }
- }
- gdb_assert (WIFSTOPPED (wstat));
- if (WIFSTOPPED (wstat))
- {
- struct process_info *proc;
- /* Architecture-specific setup after inferior is running. */
- proc = find_process_pid (pid_of (thread));
- if (proc->tdesc == NULL)
- {
- if (proc->attached)
- {
- /* This needs to happen after we have attached to the
- inferior and it is stopped for the first time, but
- before we access any inferior registers. */
- arch_setup_thread (thread);
- }
- else
- {
- /* The process is started, but GDBserver will do
- architecture-specific setup after the program stops at
- the first instruction. */
- child->status_pending_p = 1;
- child->status_pending = wstat;
- return;
- }
- }
- }
- if (WIFSTOPPED (wstat) && child->must_set_ptrace_flags)
- {
- struct process_info *proc = find_process_pid (pid_of (thread));
- int options = linux_low_ptrace_options (proc->attached);
- linux_enable_event_reporting (lwpid, options);
- child->must_set_ptrace_flags = 0;
- }
- /* Always update syscall_state, even if it will be filtered later. */
- if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SYSCALL_SIGTRAP)
- {
- child->syscall_state
- = (child->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
- ? TARGET_WAITKIND_SYSCALL_RETURN
- : TARGET_WAITKIND_SYSCALL_ENTRY);
- }
- else
- {
- /* Almost all other ptrace-stops are known to be outside of system
- calls, with further exceptions in handle_extended_wait. */
- child->syscall_state = TARGET_WAITKIND_IGNORE;
- }
- /* Be careful to not overwrite stop_pc until save_stop_reason is
- called. */
- if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGTRAP
- && linux_is_extended_waitstatus (wstat))
- {
- child->stop_pc = get_pc (child);
- if (handle_extended_wait (&child, wstat))
- {
- /* The event has been handled, so just return without
- reporting it. */
- return;
- }
- }
- if (linux_wstatus_maybe_breakpoint (wstat))
- {
- if (save_stop_reason (child))
- have_stop_pc = 1;
- }
- if (!have_stop_pc)
- child->stop_pc = get_pc (child);
- if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGSTOP
- && child->stop_expected)
- {
- threads_debug_printf ("Expected stop.");
- child->stop_expected = 0;
- if (thread->last_resume_kind == resume_stop)
- {
- /* We want to report the stop to the core. Treat the
- SIGSTOP as a normal event. */
- threads_debug_printf ("resume_stop SIGSTOP caught for %s.",
- target_pid_to_str (ptid_of (thread)).c_str ());
- }
- else if (stopping_threads != NOT_STOPPING_THREADS)
- {
- /* Stopping threads. We don't want this SIGSTOP to end up
- pending. */
- threads_debug_printf ("SIGSTOP caught for %s while stopping threads.",
- target_pid_to_str (ptid_of (thread)).c_str ());
- return;
- }
- else
- {
- /* This is a delayed SIGSTOP. Filter out the event. */
- threads_debug_printf ("%s %s, 0, 0 (discard delayed SIGSTOP)",
- child->stepping ? "step" : "continue",
- target_pid_to_str (ptid_of (thread)).c_str ());
- resume_one_lwp (child, child->stepping, 0, NULL);
- return;
- }
- }
- child->status_pending_p = 1;
- child->status_pending = wstat;
- return;
- }
- bool
- linux_process_target::maybe_hw_step (thread_info *thread)
- {
- if (supports_hardware_single_step ())
- return true;
- else
- {
- /* GDBserver must insert single-step breakpoint for software
- single step. */
- gdb_assert (has_single_step_breakpoints (thread));
- return false;
- }
- }
- void
- linux_process_target::resume_stopped_resumed_lwps (thread_info *thread)
- {
- struct lwp_info *lp = get_thread_lwp (thread);
- if (lp->stopped
- && !lp->suspended
- && !lp->status_pending_p
- && thread->last_status.kind () == TARGET_WAITKIND_IGNORE)
- {
- int step = 0;
- if (thread->last_resume_kind == resume_step)
- step = maybe_hw_step (thread);
- threads_debug_printf ("resuming stopped-resumed LWP %s at %s: step=%d",
- target_pid_to_str (ptid_of (thread)).c_str (),
- paddress (lp->stop_pc), step);
- resume_one_lwp (lp, step, GDB_SIGNAL_0, NULL);
- }
- }
- int
- linux_process_target::wait_for_event_filtered (ptid_t wait_ptid,
- ptid_t filter_ptid,
- int *wstatp, int options)
- {
- struct thread_info *event_thread;
- struct lwp_info *event_child, *requested_child;
- sigset_t block_mask, prev_mask;
- retry:
- /* N.B. event_thread points to the thread_info struct that contains
- event_child. Keep them in sync. */
- event_thread = NULL;
- event_child = NULL;
- requested_child = NULL;
- /* Check for a lwp with a pending status. */
- if (filter_ptid == minus_one_ptid || filter_ptid.is_pid ())
- {
- event_thread = find_thread_in_random ([&] (thread_info *thread)
- {
- return status_pending_p_callback (thread, filter_ptid);
- });
- if (event_thread != NULL)
- {
- event_child = get_thread_lwp (event_thread);
- threads_debug_printf ("Got a pending child %ld", lwpid_of (event_thread));
- }
- }
- else if (filter_ptid != null_ptid)
- {
- requested_child = find_lwp_pid (filter_ptid);
- if (stopping_threads == NOT_STOPPING_THREADS
- && requested_child->status_pending_p
- && (requested_child->collecting_fast_tracepoint
- != fast_tpoint_collect_result::not_collecting))
- {
- enqueue_one_deferred_signal (requested_child,
- &requested_child->status_pending);
- requested_child->status_pending_p = 0;
- requested_child->status_pending = 0;
- resume_one_lwp (requested_child, 0, 0, NULL);
- }
- if (requested_child->suspended
- && requested_child->status_pending_p)
- {
- internal_error (__FILE__, __LINE__,
- "requesting an event out of a"
- " suspended child?");
- }
- if (requested_child->status_pending_p)
- {
- event_child = requested_child;
- event_thread = get_lwp_thread (event_child);
- }
- }
- if (event_child != NULL)
- {
- threads_debug_printf ("Got an event from pending child %ld (%04x)",
- lwpid_of (event_thread),
- event_child->status_pending);
- *wstatp = event_child->status_pending;
- event_child->status_pending_p = 0;
- event_child->status_pending = 0;
- switch_to_thread (event_thread);
- return lwpid_of (event_thread);
- }
- /* But if we don't find a pending event, we'll have to wait.
- We only enter this loop if no process has a pending wait status.
- Thus any action taken in response to a wait status inside this
- loop is responding as soon as we detect the status, not after any
- pending events. */
- /* Make sure SIGCHLD is blocked until the sigsuspend below. Block
- all signals while here. */
- sigfillset (&block_mask);
- gdb_sigmask (SIG_BLOCK, &block_mask, &prev_mask);
- /* Always pull all events out of the kernel. We'll randomly select
- an event LWP out of all that have events, to prevent
- starvation. */
- while (event_child == NULL)
- {
- pid_t ret = 0;
- /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
- quirks:
- - If the thread group leader exits while other threads in the
- thread group still exist, waitpid(TGID, ...) hangs. That
- waitpid won't return an exit status until the other threads
- in the group are reaped.
- - When a non-leader thread execs, that thread just vanishes
- without reporting an exit (so we'd hang if we waited for it
- explicitly in that case). The exec event is reported to
- the TGID pid. */
- errno = 0;
- ret = my_waitpid (-1, wstatp, options | WNOHANG);
- threads_debug_printf ("waitpid(-1, ...) returned %d, %s",
- ret, errno ? safe_strerror (errno) : "ERRNO-OK");
- if (ret > 0)
- {
- threads_debug_printf ("waitpid %ld received %s",
- (long) ret, status_to_str (*wstatp).c_str ());
- /* Filter all events. IOW, leave all events pending. We'll
- randomly select an event LWP out of all that have events
- below. */
- filter_event (ret, *wstatp);
- /* Retry until nothing comes out of waitpid. A single
- SIGCHLD can indicate more than one child stopped. */
- continue;
- }
- /* Now that we've pulled all events out of the kernel, resume
- LWPs that don't have an interesting event to report. */
- if (stopping_threads == NOT_STOPPING_THREADS)
- for_each_thread ([this] (thread_info *thread)
- {
- resume_stopped_resumed_lwps (thread);
- });
- /* ... and find an LWP with a status to report to the core, if
- any. */
- event_thread = find_thread_in_random ([&] (thread_info *thread)
- {
- return status_pending_p_callback (thread, filter_ptid);
- });
- if (event_thread != NULL)
- {
- event_child = get_thread_lwp (event_thread);
- *wstatp = event_child->status_pending;
- event_child->status_pending_p = 0;
- event_child->status_pending = 0;
- break;
- }
- /* Check for zombie thread group leaders. Those can't be reaped
- until all other threads in the thread group are. */
- check_zombie_leaders ();
- auto not_stopped = [&] (thread_info *thread)
- {
- return not_stopped_callback (thread, wait_ptid);
- };
- /* If there are no resumed children left in the set of LWPs we
- want to wait for, bail. We can't just block in
- waitpid/sigsuspend, because lwps might have been left stopped
- in trace-stop state, and we'd be stuck forever waiting for
- their status to change (which would only happen if we resumed
- them). Even if WNOHANG is set, this return code is preferred
- over 0 (below), as it is more detailed. */
- if (find_thread (not_stopped) == NULL)
- {
- threads_debug_printf ("exit (no unwaited-for LWP)");
- gdb_sigmask (SIG_SETMASK, &prev_mask, NULL);
- return -1;
- }
- /* No interesting event to report to the caller. */
- if ((options & WNOHANG))
- {
- threads_debug_printf ("WNOHANG set, no event found");
- gdb_sigmask (SIG_SETMASK, &prev_mask, NULL);
- return 0;
- }
- /* Block until we get an event reported with SIGCHLD. */
- threads_debug_printf ("sigsuspend'ing");
- sigsuspend (&prev_mask);
- gdb_sigmask (SIG_SETMASK, &prev_mask, NULL);
- goto retry;
- }
- gdb_sigmask (SIG_SETMASK, &prev_mask, NULL);
- switch_to_thread (event_thread);
- return lwpid_of (event_thread);
- }
- int
- linux_process_target::wait_for_event (ptid_t ptid, int *wstatp, int options)
- {
- return wait_for_event_filtered (ptid, ptid, wstatp, options);
- }
- /* Select one LWP out of those that have events pending. */
- static void
- select_event_lwp (struct lwp_info **orig_lp)
- {
- struct thread_info *event_thread = NULL;
- /* In all-stop, give preference to the LWP that is being
- single-stepped. There will be at most one, and it's the LWP that
- the core is most interested in. If we didn't do this, then we'd
- have to handle pending step SIGTRAPs somehow in case the core
- later continues the previously-stepped thread, otherwise we'd
- report the pending SIGTRAP, and the core, not having stepped the
- thread, wouldn't understand what the trap was for, and therefore
- would report it to the user as a random signal. */
- if (!non_stop)
- {
- event_thread = find_thread ([] (thread_info *thread)
- {
- lwp_info *lp = get_thread_lwp (thread);
- return (thread->last_status.kind () == TARGET_WAITKIND_IGNORE
- && thread->last_resume_kind == resume_step
- && lp->status_pending_p);
- });
- if (event_thread != NULL)
- threads_debug_printf
- ("Select single-step %s",
- target_pid_to_str (ptid_of (event_thread)).c_str ());
- }
- if (event_thread == NULL)
- {
- /* No single-stepping LWP. Select one at random, out of those
- which have had events. */
- event_thread = find_thread_in_random ([&] (thread_info *thread)
- {
- lwp_info *lp = get_thread_lwp (thread);
- /* Only resumed LWPs that have an event pending. */
- return (thread->last_status.kind () == TARGET_WAITKIND_IGNORE
- && lp->status_pending_p);
- });
- }
- if (event_thread != NULL)
- {
- struct lwp_info *event_lp = get_thread_lwp (event_thread);
- /* Switch the event LWP. */
- *orig_lp = event_lp;
- }
- }
- /* Decrement the suspend count of all LWPs, except EXCEPT, if non
- NULL. */
- static void
- unsuspend_all_lwps (struct lwp_info *except)
- {
- for_each_thread ([&] (thread_info *thread)
- {
- lwp_info *lwp = get_thread_lwp (thread);
- if (lwp != except)
- lwp_suspended_decr (lwp);
- });
- }
- static bool lwp_running (thread_info *thread);
- /* Stabilize threads (move out of jump pads).
- If a thread is midway collecting a fast tracepoint, we need to
- finish the collection and move it out of the jump pad before
- reporting the signal.
- This avoids recursion while collecting (when a signal arrives
- midway, and the signal handler itself collects), which would trash
- the trace buffer. In case the user set a breakpoint in a signal
- handler, this avoids the backtrace showing the jump pad, etc..
- Most importantly, there are certain things we can't do safely if
- threads are stopped in a jump pad (or in its callee's). For
- example:
- - starting a new trace run. A thread still collecting the
- previous run, could trash the trace buffer when resumed. The trace
- buffer control structures would have been reset but the thread had
- no way to tell. The thread could even midway memcpy'ing to the
- buffer, which would mean that when resumed, it would clobber the
- trace buffer that had been set for a new run.
- - we can't rewrite/reuse the jump pads for new tracepoints
- safely. Say you do tstart while a thread is stopped midway while
- collecting. When the thread is later resumed, it finishes the
- collection, and returns to the jump pad, to execute the original
- instruction that was under the tracepoint jump at the time the
- older run had been started. If the jump pad had been rewritten
- since for something else in the new run, the thread would now
- execute the wrong / random instructions. */
- void
- linux_process_target::stabilize_threads ()
- {
- thread_info *thread_stuck = find_thread ([this] (thread_info *thread)
- {
- return stuck_in_jump_pad (thread);
- });
- if (thread_stuck != NULL)
- {
- threads_debug_printf ("can't stabilize, LWP %ld is stuck in jump pad",
- lwpid_of (thread_stuck));
- return;
- }
- scoped_restore_current_thread restore_thread;
- stabilizing_threads = 1;
- /* Kick 'em all. */
- for_each_thread ([this] (thread_info *thread)
- {
- move_out_of_jump_pad (thread);
- });
- /* Loop until all are stopped out of the jump pads. */
- while (find_thread (lwp_running) != NULL)
- {
- struct target_waitstatus ourstatus;
- struct lwp_info *lwp;
- int wstat;
- /* Note that we go through the full wait even loop. While
- moving threads out of jump pad, we need to be able to step
- over internal breakpoints and such. */
- wait_1 (minus_one_ptid, &ourstatus, 0);
- if (ourstatus.kind () == TARGET_WAITKIND_STOPPED)
- {
- lwp = get_thread_lwp (current_thread);
- /* Lock it. */
- lwp_suspended_inc (lwp);
- if (ourstatus.sig () != GDB_SIGNAL_0
- || current_thread->last_resume_kind == resume_stop)
- {
- wstat = W_STOPCODE (gdb_signal_to_host (ourstatus.sig ()));
- enqueue_one_deferred_signal (lwp, &wstat);
- }
- }
- }
- unsuspend_all_lwps (NULL);
- stabilizing_threads = 0;
- if (debug_threads)
- {
- thread_stuck = find_thread ([this] (thread_info *thread)
- {
- return stuck_in_jump_pad (thread);
- });
- if (thread_stuck != NULL)
- threads_debug_printf
- ("couldn't stabilize, LWP %ld got stuck in jump pad",
- lwpid_of (thread_stuck));
- }
- }
- /* Convenience function that is called when the kernel reports an
- event that is not passed out to GDB. */
- static ptid_t
- ignore_event (struct target_waitstatus *ourstatus)
- {
- /* If we got an event, there may still be others, as a single
- SIGCHLD can indicate more than one child stopped. This forces
- another target_wait call. */
- async_file_mark ();
- ourstatus->set_ignore ();
- return null_ptid;
- }
- ptid_t
- linux_process_target::filter_exit_event (lwp_info *event_child,
- target_waitstatus *ourstatus)
- {
- client_state &cs = get_client_state ();
- struct thread_info *thread = get_lwp_thread (event_child);
- ptid_t ptid = ptid_of (thread);
- if (!is_leader (thread))
- {
- if (cs.report_thread_events)
- ourstatus->set_thread_exited (0);
- else
- ourstatus->set_ignore ();
- delete_lwp (event_child);
- }
- return ptid;
- }
- /* Returns 1 if GDB is interested in any event_child syscalls. */
- static int
- gdb_catching_syscalls_p (struct lwp_info *event_child)
- {
- struct thread_info *thread = get_lwp_thread (event_child);
- struct process_info *proc = get_thread_process (thread);
- return !proc->syscalls_to_catch.empty ();
- }
- bool
- linux_process_target::gdb_catch_this_syscall (lwp_info *event_child)
- {
- int sysno;
- struct thread_info *thread = get_lwp_thread (event_child);
- struct process_info *proc = get_thread_process (thread);
- if (proc->syscalls_to_catch.empty ())
- return false;
- if (proc->syscalls_to_catch[0] == ANY_SYSCALL)
- return true;
- get_syscall_trapinfo (event_child, &sysno);
- for (int iter : proc->syscalls_to_catch)
- if (iter == sysno)
- return true;
- return false;
- }
- ptid_t
- linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
- target_wait_flags target_options)
- {
- THREADS_SCOPED_DEBUG_ENTER_EXIT;
- client_state &cs = get_client_state ();
- int w;
- struct lwp_info *event_child;
- int options;
- int pid;
- int step_over_finished;
- int bp_explains_trap;
- int maybe_internal_trap;
- int report_to_gdb;
- int trace_event;
- int in_step_range;
- int any_resumed;
- threads_debug_printf ("[%s]", target_pid_to_str (ptid).c_str ());
- /* Translate generic target options into linux options. */
- options = __WALL;
- if (target_options & TARGET_WNOHANG)
- options |= WNOHANG;
- bp_explains_trap = 0;
- trace_event = 0;
- in_step_range = 0;
- ourstatus->set_ignore ();
- auto status_pending_p_any = [&] (thread_info *thread)
- {
- return status_pending_p_callback (thread, minus_one_ptid);
- };
- auto not_stopped = [&] (thread_info *thread)
- {
- return not_stopped_callback (thread, minus_one_ptid);
- };
- /* Find a resumed LWP, if any. */
- if (find_thread (status_pending_p_any) != NULL)
- any_resumed = 1;
- else if (find_thread (not_stopped) != NULL)
- any_resumed = 1;
- else
- any_resumed = 0;
- if (step_over_bkpt == null_ptid)
- pid = wait_for_event (ptid, &w, options);
- else
- {
- threads_debug_printf ("step_over_bkpt set [%s], doing a blocking wait",
- target_pid_to_str (step_over_bkpt).c_str ());
- pid = wait_for_event (step_over_bkpt, &w, options & ~WNOHANG);
- }
- if (pid == 0 || (pid == -1 && !any_resumed))
- {
- gdb_assert (target_options & TARGET_WNOHANG);
- threads_debug_printf ("ret = null_ptid, TARGET_WAITKIND_IGNORE");
- ourstatus->set_ignore ();
- return null_ptid;
- }
- else if (pid == -1)
- {
- threads_debug_printf ("ret = null_ptid, TARGET_WAITKIND_NO_RESUMED");
- ourstatus->set_no_resumed ();
- return null_ptid;
- }
- event_child = get_thread_lwp (current_thread);
- /* wait_for_event only returns an exit status for the last
- child of a process. Report it. */
- if (WIFEXITED (w) || WIFSIGNALED (w))
- {
- if (WIFEXITED (w))
- {
- ourstatus->set_exited (WEXITSTATUS (w));
- threads_debug_printf
- ("ret = %s, exited with retcode %d",
- target_pid_to_str (ptid_of (current_thread)).c_str (),
- WEXITSTATUS (w));
- }
- else
- {
- ourstatus->set_signalled (gdb_signal_from_host (WTERMSIG (w)));
- threads_debug_printf
- ("ret = %s, terminated with signal %d",
- target_pid_to_str (ptid_of (current_thread)).c_str (),
- WTERMSIG (w));
- }
- if (ourstatus->kind () == TARGET_WAITKIND_EXITED)
- return filter_exit_event (event_child, ourstatus);
- return ptid_of (current_thread);
- }
- /* If step-over executes a breakpoint instruction, in the case of a
- hardware single step it means a gdb/gdbserver breakpoint had been
- planted on top of a permanent breakpoint, in the case of a software
- single step it may just mean that gdbserver hit the reinsert breakpoint.
- The PC has been adjusted by save_stop_reason to point at
- the breakpoint address.
- So in the case of the hardware single step advance the PC manually
- past the breakpoint and in the case of software single step advance only
- if it's not the single_step_breakpoint we are hitting.
- This avoids that a program would keep trapping a permanent breakpoint
- forever. */
- if (step_over_bkpt != null_ptid
- && event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
- && (event_child->stepping
- || !single_step_breakpoint_inserted_here (event_child->stop_pc)))
- {
- int increment_pc = 0;
- int breakpoint_kind = 0;
- CORE_ADDR stop_pc = event_child->stop_pc;
- breakpoint_kind = breakpoint_kind_from_current_state (&stop_pc);
- sw_breakpoint_from_kind (breakpoint_kind, &increment_pc);
- threads_debug_printf
- ("step-over for %s executed software breakpoint",
- target_pid_to_str (ptid_of (current_thread)).c_str ());
- if (increment_pc != 0)
- {
- struct regcache *regcache
- = get_thread_regcache (current_thread, 1);
- event_child->stop_pc += increment_pc;
- low_set_pc (regcache, event_child->stop_pc);
- if (!low_breakpoint_at (event_child->stop_pc))
- event_child->stop_reason = TARGET_STOPPED_BY_NO_REASON;
- }
- }
- /* If this event was not handled before, and is not a SIGTRAP, we
- report it. SIGILL and SIGSEGV are also treated as traps in case
- a breakpoint is inserted at the current PC. If this target does
- not support internal breakpoints at all, we also report the
- SIGTRAP without further processing; it's of no concern to us. */
- maybe_internal_trap
- = (low_supports_breakpoints ()
- && (WSTOPSIG (w) == SIGTRAP
- || ((WSTOPSIG (w) == SIGILL
- || WSTOPSIG (w) == SIGSEGV)
- && low_breakpoint_at (event_child->stop_pc))));
- if (maybe_internal_trap)
- {
- /* Handle anything that requires bookkeeping before deciding to
- report the event or continue waiting. */
- /* First check if we can explain the SIGTRAP with an internal
- breakpoint, or if we should possibly report the event to GDB.
- Do this before anything that may remove or insert a
- breakpoint. */
- bp_explains_trap = breakpoint_inserted_here (event_child->stop_pc);
- /* We have a SIGTRAP, possibly a step-over dance has just
- finished. If so, tweak the state machine accordingly,
- reinsert breakpoints and delete any single-step
- breakpoints. */
- step_over_finished = finish_step_over (event_child);
- /* Now invoke the callbacks of any internal breakpoints there. */
- check_breakpoints (event_child->stop_pc);
- /* Handle tracepoint data collecting. This may overflow the
- trace buffer, and cause a tracing stop, removing
- breakpoints. */
- trace_event = handle_tracepoints (event_child);
- if (bp_explains_trap)
- threads_debug_printf ("Hit a gdbserver breakpoint.");
- }
- else
- {
- /* We have some other signal, possibly a step-over dance was in
- progress, and it should be cancelled too. */
- step_over_finished = finish_step_over (event_child);
- }
- /* We have all the data we need. Either report the event to GDB, or
- resume threads and keep waiting for more. */
- /* If we're collecting a fast tracepoint, finish the collection and
- move out of the jump pad before delivering a signal. See
- linux_stabilize_threads. */
- if (WIFSTOPPED (w)
- && WSTOPSIG (w) != SIGTRAP
- && supports_fast_tracepoints ()
- && agent_loaded_p ())
- {
- threads_debug_printf ("Got signal %d for LWP %ld. Check if we need "
- "to defer or adjust it.",
- WSTOPSIG (w), lwpid_of (current_thread));
- /* Allow debugging the jump pad itself. */
- if (current_thread->last_resume_kind != resume_step
- && maybe_move_out_of_jump_pad (event_child, &w))
- {
- enqueue_one_deferred_signal (event_child, &w);
- threads_debug_printf ("Signal %d for LWP %ld deferred (in jump pad)",
- WSTOPSIG (w), lwpid_of (current_thread));
- resume_one_lwp (event_child, 0, 0, NULL);
- return ignore_event (ourstatus);
- }
- }
- if (event_child->collecting_fast_tracepoint
- != fast_tpoint_collect_result::not_collecting)
- {
- threads_debug_printf
- ("LWP %ld was trying to move out of the jump pad (%d). "
- "Check if we're already there.",
- lwpid_of (current_thread),
- (int) event_child->collecting_fast_tracepoint);
- trace_event = 1;
- event_child->collecting_fast_tracepoint
- = linux_fast_tracepoint_collecting (event_child, NULL);
- if (event_child->collecting_fast_tracepoint
- != fast_tpoint_collect_result::before_insn)
- {
- /* No longer need this breakpoint. */
- if (event_child->exit_jump_pad_bkpt != NULL)
- {
- threads_debug_printf
- ("No longer need exit-jump-pad bkpt; removing it."
- "stopping all threads momentarily.");
- /* Other running threads could hit this breakpoint.
- We don't handle moribund locations like GDB does,
- instead we always pause all threads when removing
- breakpoints, so that any step-over or
- decr_pc_after_break adjustment is always taken
- care of while the breakpoint is still
- inserted. */
- stop_all_lwps (1, event_child);
- delete_breakpoint (event_child->exit_jump_pad_bkpt);
- event_child->exit_jump_pad_bkpt = NULL;
- unstop_all_lwps (1, event_child);
- gdb_assert (event_child->suspended >= 0);
- }
- }
- if (event_child->collecting_fast_tracepoint
- == fast_tpoint_collect_result::not_collecting)
- {
- threads_debug_printf
- ("fast tracepoint finished collecting successfully.");
- /* We may have a deferred signal to report. */
- if (dequeue_one_deferred_signal (event_child, &w))
- threads_debug_printf ("dequeued one signal.");
- else
- {
- threads_debug_printf ("no deferred signals.");
- if (stabilizing_threads)
- {
- ourstatus->set_stopped (GDB_SIGNAL_0);
- threads_debug_printf
- ("ret = %s, stopped while stabilizing threads",
- target_pid_to_str (ptid_of (current_thread)).c_str ());
- return ptid_of (current_thread);
- }
- }
- }
- }
- /* Check whether GDB would be interested in this event. */
- /* Check if GDB is interested in this syscall. */
- if (WIFSTOPPED (w)
- && WSTOPSIG (w) == SYSCALL_SIGTRAP
- && !gdb_catch_this_syscall (event_child))
- {
- threads_debug_printf ("Ignored syscall for LWP %ld.",
- lwpid_of (current_thread));
- resume_one_lwp (event_child, event_child->stepping, 0, NULL);
- return ignore_event (ourstatus);
- }
- /* If GDB is not interested in this signal, don't stop other
- threads, and don't report it to GDB. Just resume the inferior
- right away. We do this for threading-related signals as well as
- any that GDB specifically requested we ignore. But never ignore
- SIGSTOP if we sent it ourselves, and do not ignore signals when
- stepping - they may require special handling to skip the signal
- handler. Also never ignore signals that could be caused by a
- breakpoint. */
- if (WIFSTOPPED (w)
- && current_thread->last_resume_kind != resume_step
- && (
- #if defined (USE_THREAD_DB) && !defined (__ANDROID__)
- (current_process ()->priv->thread_db != NULL
- && (WSTOPSIG (w) == __SIGRTMIN
- || WSTOPSIG (w) == __SIGRTMIN + 1))
- ||
- #endif
- (cs.pass_signals[gdb_signal_from_host (WSTOPSIG (w))]
- && !(WSTOPSIG (w) == SIGSTOP
- && current_thread->last_resume_kind == resume_stop)
- && !linux_wstatus_maybe_breakpoint (w))))
- {
- siginfo_t info, *info_p;
- threads_debug_printf ("Ignored signal %d for LWP %ld.",
- WSTOPSIG (w), lwpid_of (current_thread));
- if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
- (PTRACE_TYPE_ARG3) 0, &info) == 0)
- info_p = &info;
- else
- info_p = NULL;
- if (step_over_finished)
- {
- /* We cancelled this thread's step-over above. We still
- need to unsuspend all other LWPs, and set them back
- running again while the signal handler runs. */
- unsuspend_all_lwps (event_child);
- /* Enqueue the pending signal info so that proceed_all_lwps
- doesn't lose it. */
- enqueue_pending_signal (event_child, WSTOPSIG (w), info_p);
- proceed_all_lwps ();
- }
- else
- {
- resume_one_lwp (event_child, event_child->stepping,
- WSTOPSIG (w), info_p);
- }
- return ignore_event (ourstatus);
- }
- /* Note that all addresses are always "out of the step range" when
- there's no range to begin with. */
- in_step_range = lwp_in_step_range (event_child);
- /* If GDB wanted this thread to single step, and the thread is out
- of the step range, we always want to report the SIGTRAP, and let
- GDB handle it. Watchpoints should always be reported. So should
- signals we can't explain. A SIGTRAP we can't explain could be a
- GDB breakpoint --- we may or not support Z0 breakpoints. If we
- do, we're be able to handle GDB breakpoints on top of internal
- breakpoints, by handling the internal breakpoint and still
- reporting the event to GDB. If we don't, we're out of luck, GDB
- won't see the breakpoint hit. If we see a single-step event but
- the thread should be continuing, don't pass the trap to gdb.
- That indicates that we had previously finished a single-step but
- left the single-step pending -- see
- complete_ongoing_step_over. */
- report_to_gdb = (!maybe_internal_trap
- || (current_thread->last_resume_kind == resume_step
- && !in_step_range)
- || event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
- || (!in_step_range
- && !bp_explains_trap
- && !trace_event
- && !step_over_finished
- && !(current_thread->last_resume_kind == resume_continue
- && event_child->stop_reason == TARGET_STOPPED_BY_SINGLE_STEP))
- || (gdb_breakpoint_here (event_child->stop_pc)
- && gdb_condition_true_at_breakpoint (event_child->stop_pc)
- && gdb_no_commands_at_breakpoint (event_child->stop_pc))
- || event_child->waitstatus.kind () != TARGET_WAITKIND_IGNORE);
- run_breakpoint_commands (event_child->stop_pc);
- /* We found no reason GDB would want us to stop. We either hit one
- of our own breakpoints, or finished an internal step GDB
- shouldn't know about. */
- if (!report_to_gdb)
- {
- if (bp_explains_trap)
- threads_debug_printf ("Hit a gdbserver breakpoint.");
- if (step_over_finished)
- threads_debug_printf ("Step-over finished.");
- if (trace_event)
- threads_debug_printf ("Tracepoint event.");
- if (lwp_in_step_range (event_child))
- threads_debug_printf ("Range stepping pc 0x%s [0x%s, 0x%s).",
- paddress (event_child->stop_pc),
- paddress (event_child->step_range_start),
- paddress (event_child->step_range_end));
- /* We're not reporting this breakpoint to GDB, so apply the
- decr_pc_after_break adjustment to the inferior's regcache
- ourselves. */
- if (low_supports_breakpoints ())
- {
- struct regcache *regcache
- = get_thread_regcache (current_thread, 1);
- low_set_pc (regcache, event_child->stop_pc);
- }
- if (step_over_finished)
- {
- /* If we have finished stepping over a breakpoint, we've
- stopped and suspended all LWPs momentarily except the
- stepping one. This is where we resume them all again.
- We're going to keep waiting, so use proceed, which
- handles stepping over the next breakpoint. */
- unsuspend_all_lwps (event_child);
- }
- else
- {
- /* Remove the single-step breakpoints if any. Note that
- there isn't single-step breakpoint if we finished stepping
- over. */
- if (supports_software_single_step ()
- && has_single_step_breakpoints (current_thread))
- {
- stop_all_lwps (0, event_child);
- delete_single_step_breakpoints (current_thread);
- unstop_all_lwps (0, event_child);
- }
- }
- threads_debug_printf ("proceeding all threads.");
- proceed_all_lwps ();
- return ignore_event (ourstatus);
- }
- if (debug_threads)
- {
- if (event_child->waitstatus.kind () != TARGET_WAITKIND_IGNORE)
- threads_debug_printf ("LWP %ld: extended event with waitstatus %s",
- lwpid_of (get_lwp_thread (event_child)),
- event_child->waitstatus.to_string ().c_str ());
- if (current_thread->last_resume_kind == resume_step)
- {
- if (event_child->step_range_start == event_child->step_range_end)
- threads_debug_printf
- ("GDB wanted to single-step, reporting event.");
- else if (!lwp_in_step_range (event_child))
- threads_debug_printf ("Out of step range, reporting event.");
- }
- if (event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
- threads_debug_printf ("Stopped by watchpoint.");
- else if (gdb_breakpoint_here (event_child->stop_pc))
- threads_debug_printf ("Stopped by GDB breakpoint.");
- }
- threads_debug_printf ("Hit a non-gdbserver trap event.");
- /* Alright, we're going to report a stop. */
- /* Remove single-step breakpoints. */
- if (supports_software_single_step ())
- {
- /* Remove single-step breakpoints or not. It it is true, stop all
- lwps, so that other threads won't hit the breakpoint in the
- staled memory. */
- int remove_single_step_breakpoints_p = 0;
- if (non_stop)
- {
- remove_single_step_breakpoints_p
- = has_single_step_breakpoints (current_thread);
- }
- else
- {
- /* In all-stop, a stop reply cancels all previous resume
- requests. Delete all single-step breakpoints. */
- find_thread ([&] (thread_info *thread) {
- if (has_single_step_breakpoints (thread))
- {
- remove_single_step_breakpoints_p = 1;
- return true;
- }
- return false;
- });
- }
- if (remove_single_step_breakpoints_p)
- {
- /* If we remove single-step breakpoints from memory, stop all lwps,
- so that other threads won't hit the breakpoint in the staled
- memory. */
- stop_all_lwps (0, event_child);
- if (non_stop)
- {
- gdb_assert (has_single_step_breakpoints (current_thread));
- delete_single_step_breakpoints (current_thread);
- }
- else
- {
- for_each_thread ([] (thread_info *thread){
- if (has_single_step_breakpoints (thread))
- delete_single_step_breakpoints (thread);
- });
- }
- unstop_all_lwps (0, event_child);
- }
- }
- if (!stabilizing_threads)
- {
- /* In all-stop, stop all threads. */
- if (!non_stop)
- stop_all_lwps (0, NULL);
- if (step_over_finished)
- {
- if (!non_stop)
- {
- /* If we were doing a step-over, all other threads but
- the stepping one had been paused in start_step_over,
- with their suspend counts incremented. We don't want
- to do a full unstop/unpause, because we're in
- all-stop mode (so we want threads stopped), but we
- still need to unsuspend the other threads, to
- decrement their `suspended' count back. */
- unsuspend_all_lwps (event_child);
- }
- else
- {
- /* If we just finished a step-over, then all threads had
- been momentarily paused. In all-stop, that's fine,
- we want threads stopped by now anyway. In non-stop,
- we need to re-resume threads that GDB wanted to be
- running. */
- unstop_all_lwps (1, event_child);
- }
- }
- /* If we're not waiting for a specific LWP, choose an event LWP
- from among those that have had events. Giving equal priority
- to all LWPs that have had events helps prevent
- starvation. */
- if (ptid == minus_one_ptid)
- {
- event_child->status_pending_p = 1;
- event_child->status_pending = w;
- select_event_lwp (&event_child);
- /* current_thread and event_child must stay in sync. */
- switch_to_thread (get_lwp_thread (event_child));
- event_child->status_pending_p = 0;
- w = event_child->status_pending;
- }
- /* Stabilize threads (move out of jump pads). */
- if (!non_stop)
- target_stabilize_threads ();
- }
- else
- {
- /* If we just finished a step-over, then all threads had been
- momentarily paused. In all-stop, that's fine, we want
- threads stopped by now anyway. In non-stop, we need to
- re-resume threads that GDB wanted to be running. */
- if (step_over_finished)
- unstop_all_lwps (1, event_child);
- }
- /* At this point, we haven't set OURSTATUS. This is where we do it. */
- gdb_assert (ourstatus->kind () == TARGET_WAITKIND_IGNORE);
- if (event_child->waitstatus.kind () != TARGET_WAITKIND_IGNORE)
- {
- /* If the reported event is an exit, fork, vfork or exec, let
- GDB know. */
- /* Break the unreported fork relationship chain. */
- if (event_child->waitstatus.kind () == TARGET_WAITKIND_FORKED
- || event_child->waitstatus.kind () == TARGET_WAITKIND_VFORKED)
- {
- event_child->fork_relative->fork_relative = NULL;
- event_child->fork_relative = NULL;
- }
- *ourstatus = event_child->waitstatus;
- /* Clear the event lwp's waitstatus since we handled it already. */
- event_child->waitstatus.set_ignore ();
- }
- else
- {
- /* The LWP stopped due to a plain signal or a syscall signal. Either way,
- event_chid->waitstatus wasn't filled in with the details, so look at
- the wait status W. */
- if (WSTOPSIG (w) == SYSCALL_SIGTRAP)
- {
- int syscall_number;
- get_syscall_trapinfo (event_child, &syscall_number);
- if (event_child->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY)
- ourstatus->set_syscall_entry (syscall_number);
- else if (event_child->syscall_state == TARGET_WAITKIND_SYSCALL_RETURN)
- ourstatus->set_syscall_return (syscall_number);
- else
- gdb_assert_not_reached ("unexpected syscall state");
- }
- else if (current_thread->last_resume_kind == resume_stop
- && WSTOPSIG (w) == SIGSTOP)
- {
- /* A thread that has been requested to stop by GDB with vCont;t,
- and it stopped cleanly, so report as SIG0. The use of
- SIGSTOP is an implementation detail. */
- ourstatus->set_stopped (GDB_SIGNAL_0);
- }
- else
- ourstatus->set_stopped (gdb_signal_from_host (WSTOPSIG (w)));
- }
- /* Now that we've selected our final event LWP, un-adjust its PC if
- it was a software breakpoint, and the client doesn't know we can
- adjust the breakpoint ourselves. */
- if (event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
- && !cs.swbreak_feature)
- {
- int decr_pc = low_decr_pc_after_break ();
- if (decr_pc != 0)
- {
- struct regcache *regcache
- = get_thread_regcache (current_thread, 1);
- low_set_pc (regcache, event_child->stop_pc + decr_pc);
- }
- }
- gdb_assert (step_over_bkpt == null_ptid);
- threads_debug_printf ("ret = %s, %s",
- target_pid_to_str (ptid_of (current_thread)).c_str (),
- ourstatus->to_string ().c_str ());
- if (ourstatus->kind () == TARGET_WAITKIND_EXITED)
- return filter_exit_event (event_child, ourstatus);
- return ptid_of (current_thread);
- }
- /* Get rid of any pending event in the pipe. */
- static void
- async_file_flush (void)
- {
- linux_event_pipe.flush ();
- }
- /* Put something in the pipe, so the event loop wakes up. */
- static void
- async_file_mark (void)
- {
- linux_event_pipe.mark ();
- }
- ptid_t
- linux_process_target::wait (ptid_t ptid,
- target_waitstatus *ourstatus,
- target_wait_flags target_options)
- {
- ptid_t event_ptid;
- /* Flush the async file first. */
- if (target_is_async_p ())
- async_file_flush ();
- do
- {
- event_ptid = wait_1 (ptid, ourstatus, target_options);
- }
- while ((target_options & TARGET_WNOHANG) == 0
- && event_ptid == null_ptid
- && ourstatus->kind () == TARGET_WAITKIND_IGNORE);
- /* If at least one stop was reported, there may be more. A single
- SIGCHLD can signal more than one child stop. */
- if (target_is_async_p ()
- && (target_options & TARGET_WNOHANG) != 0
- && event_ptid != null_ptid)
- async_file_mark ();
- return event_ptid;
- }
- /* Send a signal to an LWP. */
- static int
- kill_lwp (unsigned long lwpid, int signo)
- {
- int ret;
- errno = 0;
- ret = syscall (__NR_tkill, lwpid, signo);
- if (errno == ENOSYS)
- {
- /* If tkill fails, then we are not using nptl threads, a
- configuration we no longer support. */
- perror_with_name (("tkill"));
- }
- return ret;
- }
- void
- linux_stop_lwp (struct lwp_info *lwp)
- {
- send_sigstop (lwp);
- }
- static void
- send_sigstop (struct lwp_info *lwp)
- {
- int pid;
- pid = lwpid_of (get_lwp_thread (lwp));
- /* If we already have a pending stop signal for this process, don't
- send another. */
- if (lwp->stop_expected)
- {
- threads_debug_printf ("Have pending sigstop for lwp %d", pid);
- return;
- }
- threads_debug_printf ("Sending sigstop to lwp %d", pid);
- lwp->stop_expected = 1;
- kill_lwp (pid, SIGSTOP);
- }
- static void
- send_sigstop (thread_info *thread, lwp_info *except)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- /* Ignore EXCEPT. */
- if (lwp == except)
- return;
- if (lwp->stopped)
- return;
- send_sigstop (lwp);
- }
- /* Increment the suspend count of an LWP, and stop it, if not stopped
- yet. */
- static void
- suspend_and_send_sigstop (thread_info *thread, lwp_info *except)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- /* Ignore EXCEPT. */
- if (lwp == except)
- return;
- lwp_suspended_inc (lwp);
- send_sigstop (thread, except);
- }
- static void
- mark_lwp_dead (struct lwp_info *lwp, int wstat)
- {
- /* Store the exit status for later. */
- lwp->status_pending_p = 1;
- lwp->status_pending = wstat;
- /* Store in waitstatus as well, as there's nothing else to process
- for this event. */
- if (WIFEXITED (wstat))
- lwp->waitstatus.set_exited (WEXITSTATUS (wstat));
- else if (WIFSIGNALED (wstat))
- lwp->waitstatus.set_signalled (gdb_signal_from_host (WTERMSIG (wstat)));
- /* Prevent trying to stop it. */
- lwp->stopped = 1;
- /* No further stops are expected from a dead lwp. */
- lwp->stop_expected = 0;
- }
- /* Return true if LWP has exited already, and has a pending exit event
- to report to GDB. */
- static int
- lwp_is_marked_dead (struct lwp_info *lwp)
- {
- return (lwp->status_pending_p
- && (WIFEXITED (lwp->status_pending)
- || WIFSIGNALED (lwp->status_pending)));
- }
- void
- linux_process_target::wait_for_sigstop ()
- {
- struct thread_info *saved_thread;
- ptid_t saved_tid;
- int wstat;
- int ret;
- saved_thread = current_thread;
- if (saved_thread != NULL)
- saved_tid = saved_thread->id;
- else
- saved_tid = null_ptid; /* avoid bogus unused warning */
- scoped_restore_current_thread restore_thread;
- threads_debug_printf ("pulling events");
- /* Passing NULL_PTID as filter indicates we want all events to be
- left pending. Eventually this returns when there are no
- unwaited-for children left. */
- ret = wait_for_event_filtered (minus_one_ptid, null_ptid, &wstat, __WALL);
- gdb_assert (ret == -1);
- if (saved_thread == NULL || mythread_alive (saved_tid))
- return;
- else
- {
- threads_debug_printf ("Previously current thread died.");
- /* We can't change the current inferior behind GDB's back,
- otherwise, a subsequent command may apply to the wrong
- process. */
- restore_thread.dont_restore ();
- switch_to_thread (nullptr);
- }
- }
- bool
- linux_process_target::stuck_in_jump_pad (thread_info *thread)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- if (lwp->suspended != 0)
- {
- internal_error (__FILE__, __LINE__,
- "LWP %ld is suspended, suspended=%d\n",
- lwpid_of (thread), lwp->suspended);
- }
- gdb_assert (lwp->stopped);
- /* Allow debugging the jump pad, gdb_collect, etc.. */
- return (supports_fast_tracepoints ()
- && agent_loaded_p ()
- && (gdb_breakpoint_here (lwp->stop_pc)
- || lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
- || thread->last_resume_kind == resume_step)
- && (linux_fast_tracepoint_collecting (lwp, NULL)
- != fast_tpoint_collect_result::not_collecting));
- }
- void
- linux_process_target::move_out_of_jump_pad (thread_info *thread)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- int *wstat;
- if (lwp->suspended != 0)
- {
- internal_error (__FILE__, __LINE__,
- "LWP %ld is suspended, suspended=%d\n",
- lwpid_of (thread), lwp->suspended);
- }
- gdb_assert (lwp->stopped);
- /* For gdb_breakpoint_here. */
- scoped_restore_current_thread restore_thread;
- switch_to_thread (thread);
- wstat = lwp->status_pending_p ? &lwp->status_pending : NULL;
- /* Allow debugging the jump pad, gdb_collect, etc. */
- if (!gdb_breakpoint_here (lwp->stop_pc)
- && lwp->stop_reason != TARGET_STOPPED_BY_WATCHPOINT
- && thread->last_resume_kind != resume_step
- && maybe_move_out_of_jump_pad (lwp, wstat))
- {
- threads_debug_printf ("LWP %ld needs stabilizing (in jump pad)",
- lwpid_of (thread));
- if (wstat)
- {
- lwp->status_pending_p = 0;
- enqueue_one_deferred_signal (lwp, wstat);
- threads_debug_printf ("Signal %d for LWP %ld deferred (in jump pad",
- WSTOPSIG (*wstat), lwpid_of (thread));
- }
- resume_one_lwp (lwp, 0, 0, NULL);
- }
- else
- lwp_suspended_inc (lwp);
- }
- static bool
- lwp_running (thread_info *thread)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- if (lwp_is_marked_dead (lwp))
- return false;
- return !lwp->stopped;
- }
- void
- linux_process_target::stop_all_lwps (int suspend, lwp_info *except)
- {
- /* Should not be called recursively. */
- gdb_assert (stopping_threads == NOT_STOPPING_THREADS);
- THREADS_SCOPED_DEBUG_ENTER_EXIT;
- threads_debug_printf
- ("%s, except=%s", suspend ? "stop-and-suspend" : "stop",
- (except != NULL
- ? target_pid_to_str (ptid_of (get_lwp_thread (except))).c_str ()
- : "none"));
- stopping_threads = (suspend
- ? STOPPING_AND_SUSPENDING_THREADS
- : STOPPING_THREADS);
- if (suspend)
- for_each_thread ([&] (thread_info *thread)
- {
- suspend_and_send_sigstop (thread, except);
- });
- else
- for_each_thread ([&] (thread_info *thread)
- {
- send_sigstop (thread, except);
- });
- wait_for_sigstop ();
- stopping_threads = NOT_STOPPING_THREADS;
- threads_debug_printf ("setting stopping_threads back to !stopping");
- }
- /* Enqueue one signal in the chain of signals which need to be
- delivered to this process on next resume. */
- static void
- enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info)
- {
- lwp->pending_signals.emplace_back (signal);
- if (info == nullptr)
- memset (&lwp->pending_signals.back ().info, 0, sizeof (siginfo_t));
- else
- lwp->pending_signals.back ().info = *info;
- }
- void
- linux_process_target::install_software_single_step_breakpoints (lwp_info *lwp)
- {
- struct thread_info *thread = get_lwp_thread (lwp);
- struct regcache *regcache = get_thread_regcache (thread, 1);
- scoped_restore_current_thread restore_thread;
- switch_to_thread (thread);
- std::vector<CORE_ADDR> next_pcs = low_get_next_pcs (regcache);
- for (CORE_ADDR pc : next_pcs)
- set_single_step_breakpoint (pc, current_ptid);
- }
- int
- linux_process_target::single_step (lwp_info* lwp)
- {
- int step = 0;
- if (supports_hardware_single_step ())
- {
- step = 1;
- }
- else if (supports_software_single_step ())
- {
- install_software_single_step_breakpoints (lwp);
- step = 0;
- }
- else
- threads_debug_printf ("stepping is not implemented on this target");
- return step;
- }
- /* The signal can be delivered to the inferior if we are not trying to
- finish a fast tracepoint collect. Since signal can be delivered in
- the step-over, the program may go to signal handler and trap again
- after return from the signal handler. We can live with the spurious
- double traps. */
- static int
- lwp_signal_can_be_delivered (struct lwp_info *lwp)
- {
- return (lwp->collecting_fast_tracepoint
- == fast_tpoint_collect_result::not_collecting);
- }
- void
- linux_process_target::resume_one_lwp_throw (lwp_info *lwp, int step,
- int signal, siginfo_t *info)
- {
- struct thread_info *thread = get_lwp_thread (lwp);
- int ptrace_request;
- struct process_info *proc = get_thread_process (thread);
- /* Note that target description may not be initialised
- (proc->tdesc == NULL) at this point because the program hasn't
- stopped at the first instruction yet. It means GDBserver skips
- the extra traps from the wrapper program (see option --wrapper).
- Code in this function that requires register access should be
- guarded by proc->tdesc == NULL or something else. */
- if (lwp->stopped == 0)
- return;
- gdb_assert (lwp->waitstatus.kind () == TARGET_WAITKIND_IGNORE);
- fast_tpoint_collect_result fast_tp_collecting
- = lwp->collecting_fast_tracepoint;
- gdb_assert (!stabilizing_threads
- || (fast_tp_collecting
- != fast_tpoint_collect_result::not_collecting));
- /* Cancel actions that rely on GDB not changing the PC (e.g., the
- user used the "jump" command, or "set $pc = foo"). */
- if (thread->while_stepping != NULL && lwp->stop_pc != get_pc (lwp))
- {
- /* Collecting 'while-stepping' actions doesn't make sense
- anymore. */
- release_while_stepping_state_list (thread);
- }
- /* If we have pending signals or status, and a new signal, enqueue the
- signal. Also enqueue the signal if it can't be delivered to the
- inferior right now. */
- if (signal != 0
- && (lwp->status_pending_p
- || !lwp->pending_signals.empty ()
- || !lwp_signal_can_be_delivered (lwp)))
- {
- enqueue_pending_signal (lwp, signal, info);
- /* Postpone any pending signal. It was enqueued above. */
- signal = 0;
- }
- if (lwp->status_pending_p)
- {
- threads_debug_printf
- ("Not resuming lwp %ld (%s, stop %s); has pending status",
- lwpid_of (thread), step ? "step" : "continue",
- lwp->stop_expected ? "expected" : "not expected");
- return;
- }
- scoped_restore_current_thread restore_thread;
- switch_to_thread (thread);
- /* This bit needs some thinking about. If we get a signal that
- we must report while a single-step reinsert is still pending,
- we often end up resuming the thread. It might be better to
- (ew) allow a stack of pending events; then we could be sure that
- the reinsert happened right away and not lose any signals.
- Making this stack would also shrink the window in which breakpoints are
- uninserted (see comment in linux_wait_for_lwp) but not enough for
- complete correctness, so it won't solve that problem. It may be
- worthwhile just to solve this one, however. */
- if (lwp->bp_reinsert != 0)
- {
- threads_debug_printf (" pending reinsert at 0x%s",
- paddress (lwp->bp_reinsert));
- if (supports_hardware_single_step ())
- {
- if (fast_tp_collecting == fast_tpoint_collect_result::not_collecting)
- {
- if (step == 0)
- warning ("BAD - reinserting but not stepping.");
- if (lwp->suspended)
- warning ("BAD - reinserting and suspended(%d).",
- lwp->suspended);
- }
- }
- step = maybe_hw_step (thread);
- }
- if (fast_tp_collecting == fast_tpoint_collect_result::before_insn)
- threads_debug_printf
- ("lwp %ld wants to get out of fast tracepoint jump pad "
- "(exit-jump-pad-bkpt)", lwpid_of (thread));
- else if (fast_tp_collecting == fast_tpoint_collect_result::at_insn)
- {
- threads_debug_printf
- ("lwp %ld wants to get out of fast tracepoint jump pad single-stepping",
- lwpid_of (thread));
- if (supports_hardware_single_step ())
- step = 1;
- else
- {
- internal_error (__FILE__, __LINE__,
- "moving out of jump pad single-stepping"
- " not implemented on this target");
- }
- }
- /* If we have while-stepping actions in this thread set it stepping.
- If we have a signal to deliver, it may or may not be set to
- SIG_IGN, we don't know. Assume so, and allow collecting
- while-stepping into a signal handler. A possible smart thing to
- do would be to set an internal breakpoint at the signal return
- address, continue, and carry on catching this while-stepping
- action only when that breakpoint is hit. A future
- enhancement. */
- if (thread->while_stepping != NULL)
- {
- threads_debug_printf
- ("lwp %ld has a while-stepping action -> forcing step.",
- lwpid_of (thread));
- step = single_step (lwp);
- }
- if (proc->tdesc != NULL && low_supports_breakpoints ())
- {
- struct regcache *regcache = get_thread_regcache (current_thread, 1);
- lwp->stop_pc = low_get_pc (regcache);
- threads_debug_printf (" %s from pc 0x%lx", step ? "step" : "continue",
- (long) lwp->stop_pc);
- }
- /* If we have pending signals, consume one if it can be delivered to
- the inferior. */
- if (!lwp->pending_signals.empty () && lwp_signal_can_be_delivered (lwp))
- {
- const pending_signal &p_sig = lwp->pending_signals.front ();
- signal = p_sig.signal;
- if (p_sig.info.si_signo != 0)
- ptrace (PTRACE_SETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
- &p_sig.info);
- lwp->pending_signals.pop_front ();
- }
- threads_debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)",
- lwpid_of (thread), step ? "step" : "continue", signal,
- lwp->stop_expected ? "expected" : "not expected");
- low_prepare_to_resume (lwp);
- regcache_invalidate_thread (thread);
- errno = 0;
- lwp->stepping = step;
- if (step)
- ptrace_request = PTRACE_SINGLESTEP;
- else if (gdb_catching_syscalls_p (lwp))
- ptrace_request = PTRACE_SYSCALL;
- else
- ptrace_request = PTRACE_CONT;
- ptrace (ptrace_request,
- lwpid_of (thread),
- (PTRACE_TYPE_ARG3) 0,
- /* Coerce to a uintptr_t first to avoid potential gcc warning
- of coercing an 8 byte integer to a 4 byte pointer. */
- (PTRACE_TYPE_ARG4) (uintptr_t) signal);
- if (errno)
- {
- int saved_errno = errno;
- threads_debug_printf ("ptrace errno = %d (%s)",
- saved_errno, strerror (saved_errno));
- errno = saved_errno;
- perror_with_name ("resuming thread");
- }
- /* Successfully resumed. Clear state that no longer makes sense,
- and mark the LWP as running. Must not do this before resuming
- otherwise if that fails other code will be confused. E.g., we'd
- later try to stop the LWP and hang forever waiting for a stop
- status. Note that we must not throw after this is cleared,
- otherwise handle_zombie_lwp_error would get confused. */
- lwp->stopped = 0;
- lwp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
- }
- void
- linux_process_target::low_prepare_to_resume (lwp_info *lwp)
- {
- /* Nop. */
- }
- /* Called when we try to resume a stopped LWP and that errors out. If
- the LWP is no longer in ptrace-stopped state (meaning it's zombie,
- or about to become), discard the error, clear any pending status
- the LWP may have, and return true (we'll collect the exit status
- soon enough). Otherwise, return false. */
- static int
- check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
- {
- struct thread_info *thread = get_lwp_thread (lp);
- /* If we get an error after resuming the LWP successfully, we'd
- confuse !T state for the LWP being gone. */
- gdb_assert (lp->stopped);
- /* We can't just check whether the LWP is in 'Z (Zombie)' state,
- because even if ptrace failed with ESRCH, the tracee may be "not
- yet fully dead", but already refusing ptrace requests. In that
- case the tracee has 'R (Running)' state for a little bit
- (observed in Linux 3.18). See also the note on ESRCH in the
- ptrace(2) man page. Instead, check whether the LWP has any state
- other than ptrace-stopped. */
- /* Don't assume anything if /proc/PID/status can't be read. */
- if (linux_proc_pid_is_trace_stopped_nowarn (lwpid_of (thread)) == 0)
- {
- lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
- lp->status_pending_p = 0;
- return 1;
- }
- return 0;
- }
- void
- linux_process_target::resume_one_lwp (lwp_info *lwp, int step, int signal,
- siginfo_t *info)
- {
- try
- {
- resume_one_lwp_throw (lwp, step, signal, info);
- }
- catch (const gdb_exception_error &ex)
- {
- if (check_ptrace_stopped_lwp_gone (lwp))
- {
- /* This could because we tried to resume an LWP after its leader
- exited. Mark it as resumed, so we can collect an exit event
- from it. */
- lwp->stopped = 0;
- lwp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
- }
- else
- throw;
- }
- }
- /* This function is called once per thread via for_each_thread.
- We look up which resume request applies to THREAD and mark it with a
- pointer to the appropriate resume request.
- This algorithm is O(threads * resume elements), but resume elements
- is small (and will remain small at least until GDB supports thread
- suspension). */
- static void
- linux_set_resume_request (thread_info *thread, thread_resume *resume, size_t n)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- for (int ndx = 0; ndx < n; ndx++)
- {
- ptid_t ptid = resume[ndx].thread;
- if (ptid == minus_one_ptid
- || ptid == thread->id
- /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
- of PID'. */
- || (ptid.pid () == pid_of (thread)
- && (ptid.is_pid ()
- || ptid.lwp () == -1)))
- {
- if (resume[ndx].kind == resume_stop
- && thread->last_resume_kind == resume_stop)
- {
- threads_debug_printf
- ("already %s LWP %ld at GDB's request",
- (thread->last_status.kind () == TARGET_WAITKIND_STOPPED
- ? "stopped" : "stopping"),
- lwpid_of (thread));
- continue;
- }
- /* Ignore (wildcard) resume requests for already-resumed
- threads. */
- if (resume[ndx].kind != resume_stop
- && thread->last_resume_kind != resume_stop)
- {
- threads_debug_printf
- ("already %s LWP %ld at GDB's request",
- (thread->last_resume_kind == resume_step
- ? "stepping" : "continuing"),
- lwpid_of (thread));
- continue;
- }
- /* Don't let wildcard resumes resume fork children that GDB
- does not yet know are new fork children. */
- if (lwp->fork_relative != NULL)
- {
- struct lwp_info *rel = lwp->fork_relative;
- if (rel->status_pending_p
- && (rel->waitstatus.kind () == TARGET_WAITKIND_FORKED
- || rel->waitstatus.kind () == TARGET_WAITKIND_VFORKED))
- {
- threads_debug_printf
- ("not resuming LWP %ld: has queued stop reply",
- lwpid_of (thread));
- continue;
- }
- }
- /* If the thread has a pending event that has already been
- reported to GDBserver core, but GDB has not pulled the
- event out of the vStopped queue yet, likewise, ignore the
- (wildcard) resume request. */
- if (in_queued_stop_replies (thread->id))
- {
- threads_debug_printf
- ("not resuming LWP %ld: has queued stop reply",
- lwpid_of (thread));
- continue;
- }
- lwp->resume = &resume[ndx];
- thread->last_resume_kind = lwp->resume->kind;
- lwp->step_range_start = lwp->resume->step_range_start;
- lwp->step_range_end = lwp->resume->step_range_end;
- /* If we had a deferred signal to report, dequeue one now.
- This can happen if LWP gets more than one signal while
- trying to get out of a jump pad. */
- if (lwp->stopped
- && !lwp->status_pending_p
- && dequeue_one_deferred_signal (lwp, &lwp->status_pending))
- {
- lwp->status_pending_p = 1;
- threads_debug_printf
- ("Dequeueing deferred signal %d for LWP %ld, "
- "leaving status pending.",
- WSTOPSIG (lwp->status_pending),
- lwpid_of (thread));
- }
- return;
- }
- }
- /* No resume action for this thread. */
- lwp->resume = NULL;
- }
- bool
- linux_process_target::resume_status_pending (thread_info *thread)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- /* LWPs which will not be resumed are not interesting, because
- we might not wait for them next time through linux_wait. */
- if (lwp->resume == NULL)
- return false;
- return thread_still_has_status_pending (thread);
- }
- bool
- linux_process_target::thread_needs_step_over (thread_info *thread)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- CORE_ADDR pc;
- struct process_info *proc = get_thread_process (thread);
- /* GDBserver is skipping the extra traps from the wrapper program,
- don't have to do step over. */
- if (proc->tdesc == NULL)
- return false;
- /* LWPs which will not be resumed are not interesting, because we
- might not wait for them next time through linux_wait. */
- if (!lwp->stopped)
- {
- threads_debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped",
- lwpid_of (thread));
- return false;
- }
- if (thread->last_resume_kind == resume_stop)
- {
- threads_debug_printf
- ("Need step over [LWP %ld]? Ignoring, should remain stopped",
- lwpid_of (thread));
- return false;
- }
- gdb_assert (lwp->suspended >= 0);
- if (lwp->suspended)
- {
- threads_debug_printf ("Need step over [LWP %ld]? Ignoring, suspended",
- lwpid_of (thread));
- return false;
- }
- if (lwp->status_pending_p)
- {
- threads_debug_printf
- ("Need step over [LWP %ld]? Ignoring, has pending status.",
- lwpid_of (thread));
- return false;
- }
- /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
- or we have. */
- pc = get_pc (lwp);
- /* If the PC has changed since we stopped, then don't do anything,
- and let the breakpoint/tracepoint be hit. This happens if, for
- instance, GDB handled the decr_pc_after_break subtraction itself,
- GDB is OOL stepping this thread, or the user has issued a "jump"
- command, or poked thread's registers herself. */
- if (pc != lwp->stop_pc)
- {
- threads_debug_printf
- ("Need step over [LWP %ld]? Cancelling, PC was changed. "
- "Old stop_pc was 0x%s, PC is now 0x%s", lwpid_of (thread),
- paddress (lwp->stop_pc), paddress (pc));
- return false;
- }
- /* On software single step target, resume the inferior with signal
- rather than stepping over. */
- if (supports_software_single_step ()
- && !lwp->pending_signals.empty ()
- && lwp_signal_can_be_delivered (lwp))
- {
- threads_debug_printf
- ("Need step over [LWP %ld]? Ignoring, has pending signals.",
- lwpid_of (thread));
- return false;
- }
- scoped_restore_current_thread restore_thread;
- switch_to_thread (thread);
- /* We can only step over breakpoints we know about. */
- if (breakpoint_here (pc) || fast_tracepoint_jump_here (pc))
- {
- /* Don't step over a breakpoint that GDB expects to hit
- though. If the condition is being evaluated on the target's side
- and it evaluate to false, step over this breakpoint as well. */
- if (gdb_breakpoint_here (pc)
- && gdb_condition_true_at_breakpoint (pc)
- && gdb_no_commands_at_breakpoint (pc))
- {
- threads_debug_printf ("Need step over [LWP %ld]? yes, but found"
- " GDB breakpoint at 0x%s; skipping step over",
- lwpid_of (thread), paddress (pc));
- return false;
- }
- else
- {
- threads_debug_printf ("Need step over [LWP %ld]? yes, "
- "found breakpoint at 0x%s",
- lwpid_of (thread), paddress (pc));
- /* We've found an lwp that needs stepping over --- return 1 so
- that find_thread stops looking. */
- return true;
- }
- }
- threads_debug_printf
- ("Need step over [LWP %ld]? No, no breakpoint found at 0x%s",
- lwpid_of (thread), paddress (pc));
- return false;
- }
- void
- linux_process_target::start_step_over (lwp_info *lwp)
- {
- struct thread_info *thread = get_lwp_thread (lwp);
- CORE_ADDR pc;
- threads_debug_printf ("Starting step-over on LWP %ld. Stopping all threads",
- lwpid_of (thread));
- stop_all_lwps (1, lwp);
- if (lwp->suspended != 0)
- {
- internal_error (__FILE__, __LINE__,
- "LWP %ld suspended=%d\n", lwpid_of (thread),
- lwp->suspended);
- }
- threads_debug_printf ("Done stopping all threads for step-over.");
- /* Note, we should always reach here with an already adjusted PC,
- either by GDB (if we're resuming due to GDB's request), or by our
- caller, if we just finished handling an internal breakpoint GDB
- shouldn't care about. */
- pc = get_pc (lwp);
- bool step = false;
- {
- scoped_restore_current_thread restore_thread;
- switch_to_thread (thread);
- lwp->bp_reinsert = pc;
- uninsert_breakpoints_at (pc);
- uninsert_fast_tracepoint_jumps_at (pc);
- step = single_step (lwp);
- }
- resume_one_lwp (lwp, step, 0, NULL);
- /* Require next event from this LWP. */
- step_over_bkpt = thread->id;
- }
- bool
- linux_process_target::finish_step_over (lwp_info *lwp)
- {
- if (lwp->bp_reinsert != 0)
- {
- scoped_restore_current_thread restore_thread;
- threads_debug_printf ("Finished step over.");
- switch_to_thread (get_lwp_thread (lwp));
- /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
- may be no breakpoint to reinsert there by now. */
- reinsert_breakpoints_at (lwp->bp_reinsert);
- reinsert_fast_tracepoint_jumps_at (lwp->bp_reinsert);
- lwp->bp_reinsert = 0;
- /* Delete any single-step breakpoints. No longer needed. We
- don't have to worry about other threads hitting this trap,
- and later not being able to explain it, because we were
- stepping over a breakpoint, and we hold all threads but
- LWP stopped while doing that. */
- if (!supports_hardware_single_step ())
- {
- gdb_assert (has_single_step_breakpoints (current_thread));
- delete_single_step_breakpoints (current_thread);
- }
- step_over_bkpt = null_ptid;
- return true;
- }
- else
- return false;
- }
- void
- linux_process_target::complete_ongoing_step_over ()
- {
- if (step_over_bkpt != null_ptid)
- {
- struct lwp_info *lwp;
- int wstat;
- int ret;
- threads_debug_printf ("detach: step over in progress, finish it first");
- /* Passing NULL_PTID as filter indicates we want all events to
- be left pending. Eventually this returns when there are no
- unwaited-for children left. */
- ret = wait_for_event_filtered (minus_one_ptid, null_ptid, &wstat,
- __WALL);
- gdb_assert (ret == -1);
- lwp = find_lwp_pid (step_over_bkpt);
- if (lwp != NULL)
- {
- finish_step_over (lwp);
- /* If we got our step SIGTRAP, don't leave it pending,
- otherwise we would report it to GDB as a spurious
- SIGTRAP. */
- gdb_assert (lwp->status_pending_p);
- if (WIFSTOPPED (lwp->status_pending)
- && WSTOPSIG (lwp->status_pending) == SIGTRAP)
- {
- thread_info *thread = get_lwp_thread (lwp);
- if (thread->last_resume_kind != resume_step)
- {
- threads_debug_printf ("detach: discard step-over SIGTRAP");
- lwp->status_pending_p = 0;
- lwp->status_pending = 0;
- resume_one_lwp (lwp, lwp->stepping, 0, NULL);
- }
- else
- threads_debug_printf
- ("detach: resume_step, not discarding step-over SIGTRAP");
- }
- }
- step_over_bkpt = null_ptid;
- unsuspend_all_lwps (lwp);
- }
- }
- void
- linux_process_target::resume_one_thread (thread_info *thread,
- bool leave_all_stopped)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- int leave_pending;
- if (lwp->resume == NULL)
- return;
- if (lwp->resume->kind == resume_stop)
- {
- threads_debug_printf ("resume_stop request for LWP %ld",
- lwpid_of (thread));
- if (!lwp->stopped)
- {
- threads_debug_printf ("stopping LWP %ld", lwpid_of (thread));
- /* Stop the thread, and wait for the event asynchronously,
- through the event loop. */
- send_sigstop (lwp);
- }
- else
- {
- threads_debug_printf ("already stopped LWP %ld", lwpid_of (thread));
- /* The LWP may have been stopped in an internal event that
- was not meant to be notified back to GDB (e.g., gdbserver
- breakpoint), so we should be reporting a stop event in
- this case too. */
- /* If the thread already has a pending SIGSTOP, this is a
- no-op. Otherwise, something later will presumably resume
- the thread and this will cause it to cancel any pending
- operation, due to last_resume_kind == resume_stop. If
- the thread already has a pending status to report, we
- will still report it the next time we wait - see
- status_pending_p_callback. */
- /* If we already have a pending signal to report, then
- there's no need to queue a SIGSTOP, as this means we're
- midway through moving the LWP out of the jumppad, and we
- will report the pending signal as soon as that is
- finished. */
- if (lwp->pending_signals_to_report.empty ())
- send_sigstop (lwp);
- }
- /* For stop requests, we're done. */
- lwp->resume = NULL;
- thread->last_status.set_ignore ();
- return;
- }
- /* If this thread which is about to be resumed has a pending status,
- then don't resume it - we can just report the pending status.
- Likewise if it is suspended, because e.g., another thread is
- stepping past a breakpoint. Make sure to queue any signals that
- would otherwise be sent. In all-stop mode, we do this decision
- based on if *any* thread has a pending status. If there's a
- thread that needs the step-over-breakpoint dance, then don't
- resume any other thread but that particular one. */
- leave_pending = (lwp->suspended
- || lwp->status_pending_p
- || leave_all_stopped);
- /* If we have a new signal, enqueue the signal. */
- if (lwp->resume->sig != 0)
- {
- siginfo_t info, *info_p;
- /* If this is the same signal we were previously stopped by,
- make sure to queue its siginfo. */
- if (WIFSTOPPED (lwp->last_status)
- && WSTOPSIG (lwp->last_status) == lwp->resume->sig
- && ptrace (PTRACE_GETSIGINFO, lwpid_of (thread),
- (PTRACE_TYPE_ARG3) 0, &info) == 0)
- info_p = &info;
- else
- info_p = NULL;
- enqueue_pending_signal (lwp, lwp->resume->sig, info_p);
- }
- if (!leave_pending)
- {
- threads_debug_printf ("resuming LWP %ld", lwpid_of (thread));
- proceed_one_lwp (thread, NULL);
- }
- else
- threads_debug_printf ("leaving LWP %ld stopped", lwpid_of (thread));
- thread->last_status.set_ignore ();
- lwp->resume = NULL;
- }
- void
- linux_process_target::resume (thread_resume *resume_info, size_t n)
- {
- struct thread_info *need_step_over = NULL;
- THREADS_SCOPED_DEBUG_ENTER_EXIT;
- for_each_thread ([&] (thread_info *thread)
- {
- linux_set_resume_request (thread, resume_info, n);
- });
- /* If there is a thread which would otherwise be resumed, which has
- a pending status, then don't resume any threads - we can just
- report the pending status. Make sure to queue any signals that
- would otherwise be sent. In non-stop mode, we'll apply this
- logic to each thread individually. We consume all pending events
- before considering to start a step-over (in all-stop). */
- bool any_pending = false;
- if (!non_stop)
- any_pending = find_thread ([this] (thread_info *thread)
- {
- return resume_status_pending (thread);
- }) != nullptr;
- /* If there is a thread which would otherwise be resumed, which is
- stopped at a breakpoint that needs stepping over, then don't
- resume any threads - have it step over the breakpoint with all
- other threads stopped, then resume all threads again. Make sure
- to queue any signals that would otherwise be delivered or
- queued. */
- if (!any_pending && low_supports_breakpoints ())
- need_step_over = find_thread ([this] (thread_info *thread)
- {
- return thread_needs_step_over (thread);
- });
- bool leave_all_stopped = (need_step_over != NULL || any_pending);
- if (need_step_over != NULL)
- threads_debug_printf ("Not resuming all, need step over");
- else if (any_pending)
- threads_debug_printf ("Not resuming, all-stop and found "
- "an LWP with pending status");
- else
- threads_debug_printf ("Resuming, no pending status or step over needed");
- /* Even if we're leaving threads stopped, queue all signals we'd
- otherwise deliver. */
- for_each_thread ([&] (thread_info *thread)
- {
- resume_one_thread (thread, leave_all_stopped);
- });
- if (need_step_over)
- start_step_over (get_thread_lwp (need_step_over));
- /* We may have events that were pending that can/should be sent to
- the client now. Trigger a linux_wait call. */
- if (target_is_async_p ())
- async_file_mark ();
- }
- void
- linux_process_target::proceed_one_lwp (thread_info *thread, lwp_info *except)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- int step;
- if (lwp == except)
- return;
- threads_debug_printf ("lwp %ld", lwpid_of (thread));
- if (!lwp->stopped)
- {
- threads_debug_printf (" LWP %ld already running", lwpid_of (thread));
- return;
- }
- if (thread->last_resume_kind == resume_stop
- && thread->last_status.kind () != TARGET_WAITKIND_IGNORE)
- {
- threads_debug_printf (" client wants LWP to remain %ld stopped",
- lwpid_of (thread));
- return;
- }
- if (lwp->status_pending_p)
- {
- threads_debug_printf (" LWP %ld has pending status, leaving stopped",
- lwpid_of (thread));
- return;
- }
- gdb_assert (lwp->suspended >= 0);
- if (lwp->suspended)
- {
- threads_debug_printf (" LWP %ld is suspended", lwpid_of (thread));
- return;
- }
- if (thread->last_resume_kind == resume_stop
- && lwp->pending_signals_to_report.empty ()
- && (lwp->collecting_fast_tracepoint
- == fast_tpoint_collect_result::not_collecting))
- {
- /* We haven't reported this LWP as stopped yet (otherwise, the
- last_status.kind check above would catch it, and we wouldn't
- reach here. This LWP may have been momentarily paused by a
- stop_all_lwps call while handling for example, another LWP's
- step-over. In that case, the pending expected SIGSTOP signal
- that was queued at vCont;t handling time will have already
- been consumed by wait_for_sigstop, and so we need to requeue
- another one here. Note that if the LWP already has a SIGSTOP
- pending, this is a no-op. */
- threads_debug_printf
- ("Client wants LWP %ld to stop. Making sure it has a SIGSTOP pending",
- lwpid_of (thread));
- send_sigstop (lwp);
- }
- if (thread->last_resume_kind == resume_step)
- {
- threads_debug_printf (" stepping LWP %ld, client wants it stepping",
- lwpid_of (thread));
- /* If resume_step is requested by GDB, install single-step
- breakpoints when the thread is about to be actually resumed if
- the single-step breakpoints weren't removed. */
- if (supports_software_single_step ()
- && !has_single_step_breakpoints (thread))
- install_software_single_step_breakpoints (lwp);
- step = maybe_hw_step (thread);
- }
- else if (lwp->bp_reinsert != 0)
- {
- threads_debug_printf (" stepping LWP %ld, reinsert set",
- lwpid_of (thread));
- step = maybe_hw_step (thread);
- }
- else
- step = 0;
- resume_one_lwp (lwp, step, 0, NULL);
- }
- void
- linux_process_target::unsuspend_and_proceed_one_lwp (thread_info *thread,
- lwp_info *except)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- if (lwp == except)
- return;
- lwp_suspended_decr (lwp);
- proceed_one_lwp (thread, except);
- }
- void
- linux_process_target::proceed_all_lwps ()
- {
- struct thread_info *need_step_over;
- /* If there is a thread which would otherwise be resumed, which is
- stopped at a breakpoint that needs stepping over, then don't
- resume any threads - have it step over the breakpoint with all
- other threads stopped, then resume all threads again. */
- if (low_supports_breakpoints ())
- {
- need_step_over = find_thread ([this] (thread_info *thread)
- {
- return thread_needs_step_over (thread);
- });
- if (need_step_over != NULL)
- {
- threads_debug_printf ("found thread %ld needing a step-over",
- lwpid_of (need_step_over));
- start_step_over (get_thread_lwp (need_step_over));
- return;
- }
- }
- threads_debug_printf ("Proceeding, no step-over needed");
- for_each_thread ([this] (thread_info *thread)
- {
- proceed_one_lwp (thread, NULL);
- });
- }
- void
- linux_process_target::unstop_all_lwps (int unsuspend, lwp_info *except)
- {
- THREADS_SCOPED_DEBUG_ENTER_EXIT;
- if (except)
- threads_debug_printf ("except=(LWP %ld)",
- lwpid_of (get_lwp_thread (except)));
- else
- threads_debug_printf ("except=nullptr");
- if (unsuspend)
- for_each_thread ([&] (thread_info *thread)
- {
- unsuspend_and_proceed_one_lwp (thread, except);
- });
- else
- for_each_thread ([&] (thread_info *thread)
- {
- proceed_one_lwp (thread, except);
- });
- }
- #ifdef HAVE_LINUX_REGSETS
- #define use_linux_regsets 1
- /* Returns true if REGSET has been disabled. */
- static int
- regset_disabled (struct regsets_info *info, struct regset_info *regset)
- {
- return (info->disabled_regsets != NULL
- && info->disabled_regsets[regset - info->regsets]);
- }
- /* Disable REGSET. */
- static void
- disable_regset (struct regsets_info *info, struct regset_info *regset)
- {
- int dr_offset;
- dr_offset = regset - info->regsets;
- if (info->disabled_regsets == NULL)
- info->disabled_regsets = (char *) xcalloc (1, info->num_regsets);
- info->disabled_regsets[dr_offset] = 1;
- }
- static int
- regsets_fetch_inferior_registers (struct regsets_info *regsets_info,
- struct regcache *regcache)
- {
- struct regset_info *regset;
- int saw_general_regs = 0;
- int pid;
- struct iovec iov;
- pid = lwpid_of (current_thread);
- for (regset = regsets_info->regsets; regset->size >= 0; regset++)
- {
- void *buf, *data;
- int nt_type, res;
- if (regset->size == 0 || regset_disabled (regsets_info, regset))
- continue;
- buf = xmalloc (regset->size);
- nt_type = regset->nt_type;
- if (nt_type)
- {
- iov.iov_base = buf;
- iov.iov_len = regset->size;
- data = (void *) &iov;
- }
- else
- data = buf;
- #ifndef __sparc__
- res = ptrace (regset->get_request, pid,
- (PTRACE_TYPE_ARG3) (long) nt_type, data);
- #else
- res = ptrace (regset->get_request, pid, data, nt_type);
- #endif
- if (res < 0)
- {
- if (errno == EIO
- || (errno == EINVAL && regset->type == OPTIONAL_REGS))
- {
- /* If we get EIO on a regset, or an EINVAL and the regset is
- optional, do not try it again for this process mode. */
- disable_regset (regsets_info, regset);
- }
- else if (errno == ENODATA)
- {
- /* ENODATA may be returned if the regset is currently
- not "active". This can happen in normal operation,
- so suppress the warning in this case. */
- }
- else if (errno == ESRCH)
- {
- /* At this point, ESRCH should mean the process is
- already gone, in which case we simply ignore attempts
- to read its registers. */
- }
- else
- {
- char s[256];
- sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
- pid);
- perror (s);
- }
- }
- else
- {
- if (regset->type == GENERAL_REGS)
- saw_general_regs = 1;
- regset->store_function (regcache, buf);
- }
- free (buf);
- }
- if (saw_general_regs)
- return 0;
- else
- return 1;
- }
- static int
- regsets_store_inferior_registers (struct regsets_info *regsets_info,
- struct regcache *regcache)
- {
- struct regset_info *regset;
- int saw_general_regs = 0;
- int pid;
- struct iovec iov;
- pid = lwpid_of (current_thread);
- for (regset = regsets_info->regsets; regset->size >= 0; regset++)
- {
- void *buf, *data;
- int nt_type, res;
- if (regset->size == 0 || regset_disabled (regsets_info, regset)
- || regset->fill_function == NULL)
- continue;
- buf = xmalloc (regset->size);
- /* First fill the buffer with the current register set contents,
- in case there are any items in the kernel's regset that are
- not in gdbserver's regcache. */
- nt_type = regset->nt_type;
- if (nt_type)
- {
- iov.iov_base = buf;
- iov.iov_len = regset->size;
- data = (void *) &iov;
- }
- else
- data = buf;
- #ifndef __sparc__
- res = ptrace (regset->get_request, pid,
- (PTRACE_TYPE_ARG3) (long) nt_type, data);
- #else
- res = ptrace (regset->get_request, pid, data, nt_type);
- #endif
- if (res == 0)
- {
- /* Then overlay our cached registers on that. */
- regset->fill_function (regcache, buf);
- /* Only now do we write the register set. */
- #ifndef __sparc__
- res = ptrace (regset->set_request, pid,
- (PTRACE_TYPE_ARG3) (long) nt_type, data);
- #else
- res = ptrace (regset->set_request, pid, data, nt_type);
- #endif
- }
- if (res < 0)
- {
- if (errno == EIO
- || (errno == EINVAL && regset->type == OPTIONAL_REGS))
- {
- /* If we get EIO on a regset, or an EINVAL and the regset is
- optional, do not try it again for this process mode. */
- disable_regset (regsets_info, regset);
- }
- else if (errno == ESRCH)
- {
- /* At this point, ESRCH should mean the process is
- already gone, in which case we simply ignore attempts
- to change its registers. See also the related
- comment in resume_one_lwp. */
- free (buf);
- return 0;
- }
- else
- {
- perror ("Warning: ptrace(regsets_store_inferior_registers)");
- }
- }
- else if (regset->type == GENERAL_REGS)
- saw_general_regs = 1;
- free (buf);
- }
- if (saw_general_regs)
- return 0;
- else
- return 1;
- }
- #else /* !HAVE_LINUX_REGSETS */
- #define use_linux_regsets 0
- #define regsets_fetch_inferior_registers(regsets_info, regcache) 1
- #define regsets_store_inferior_registers(regsets_info, regcache) 1
- #endif
- /* Return 1 if register REGNO is supported by one of the regset ptrace
- calls or 0 if it has to be transferred individually. */
- static int
- linux_register_in_regsets (const struct regs_info *regs_info, int regno)
- {
- unsigned char mask = 1 << (regno % 8);
- size_t index = regno / 8;
- return (use_linux_regsets
- && (regs_info->regset_bitmap == NULL
- || (regs_info->regset_bitmap[index] & mask) != 0));
- }
- #ifdef HAVE_LINUX_USRREGS
- static int
- register_addr (const struct usrregs_info *usrregs, int regnum)
- {
- int addr;
- if (regnum < 0 || regnum >= usrregs->num_regs)
- error ("Invalid register number %d.", regnum);
- addr = usrregs->regmap[regnum];
- return addr;
- }
- void
- linux_process_target::fetch_register (const usrregs_info *usrregs,
- regcache *regcache, int regno)
- {
- CORE_ADDR regaddr;
- int i, size;
- char *buf;
- int pid;
- if (regno >= usrregs->num_regs)
- return;
- if (low_cannot_fetch_register (regno))
- return;
- regaddr = register_addr (usrregs, regno);
- if (regaddr == -1)
- return;
- size = ((register_size (regcache->tdesc, regno)
- + sizeof (PTRACE_XFER_TYPE) - 1)
- & -sizeof (PTRACE_XFER_TYPE));
- buf = (char *) alloca (size);
- pid = lwpid_of (current_thread);
- for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
- {
- errno = 0;
- *(PTRACE_XFER_TYPE *) (buf + i) =
- ptrace (PTRACE_PEEKUSER, pid,
- /* Coerce to a uintptr_t first to avoid potential gcc warning
- of coercing an 8 byte integer to a 4 byte pointer. */
- (PTRACE_TYPE_ARG3) (uintptr_t) regaddr, (PTRACE_TYPE_ARG4) 0);
- regaddr += sizeof (PTRACE_XFER_TYPE);
- if (errno != 0)
- {
- /* Mark register REGNO unavailable. */
- supply_register (regcache, regno, NULL);
- return;
- }
- }
- low_supply_ptrace_register (regcache, regno, buf);
- }
- void
- linux_process_target::store_register (const usrregs_info *usrregs,
- regcache *regcache, int regno)
- {
- CORE_ADDR regaddr;
- int i, size;
- char *buf;
- int pid;
- if (regno >= usrregs->num_regs)
- return;
- if (low_cannot_store_register (regno))
- return;
- regaddr = register_addr (usrregs, regno);
- if (regaddr == -1)
- return;
- size = ((register_size (regcache->tdesc, regno)
- + sizeof (PTRACE_XFER_TYPE) - 1)
- & -sizeof (PTRACE_XFER_TYPE));
- buf = (char *) alloca (size);
- memset (buf, 0, size);
- low_collect_ptrace_register (regcache, regno, buf);
- pid = lwpid_of (current_thread);
- for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
- {
- errno = 0;
- ptrace (PTRACE_POKEUSER, pid,
- /* Coerce to a uintptr_t first to avoid potential gcc warning
- about coercing an 8 byte integer to a 4 byte pointer. */
- (PTRACE_TYPE_ARG3) (uintptr_t) regaddr,
- (PTRACE_TYPE_ARG4) *(PTRACE_XFER_TYPE *) (buf + i));
- if (errno != 0)
- {
- /* At this point, ESRCH should mean the process is
- already gone, in which case we simply ignore attempts
- to change its registers. See also the related
- comment in resume_one_lwp. */
- if (errno == ESRCH)
- return;
- if (!low_cannot_store_register (regno))
- error ("writing register %d: %s", regno, safe_strerror (errno));
- }
- regaddr += sizeof (PTRACE_XFER_TYPE);
- }
- }
- #endif /* HAVE_LINUX_USRREGS */
- void
- linux_process_target::low_collect_ptrace_register (regcache *regcache,
- int regno, char *buf)
- {
- collect_register (regcache, regno, buf);
- }
- void
- linux_process_target::low_supply_ptrace_register (regcache *regcache,
- int regno, const char *buf)
- {
- supply_register (regcache, regno, buf);
- }
- void
- linux_process_target::usr_fetch_inferior_registers (const regs_info *regs_info,
- regcache *regcache,
- int regno, int all)
- {
- #ifdef HAVE_LINUX_USRREGS
- struct usrregs_info *usr = regs_info->usrregs;
- if (regno == -1)
- {
- for (regno = 0; regno < usr->num_regs; regno++)
- if (all || !linux_register_in_regsets (regs_info, regno))
- fetch_register (usr, regcache, regno);
- }
- else
- fetch_register (usr, regcache, regno);
- #endif
- }
- void
- linux_process_target::usr_store_inferior_registers (const regs_info *regs_info,
- regcache *regcache,
- int regno, int all)
- {
- #ifdef HAVE_LINUX_USRREGS
- struct usrregs_info *usr = regs_info->usrregs;
- if (regno == -1)
- {
- for (regno = 0; regno < usr->num_regs; regno++)
- if (all || !linux_register_in_regsets (regs_info, regno))
- store_register (usr, regcache, regno);
- }
- else
- store_register (usr, regcache, regno);
- #endif
- }
- void
- linux_process_target::fetch_registers (regcache *regcache, int regno)
- {
- int use_regsets;
- int all = 0;
- const regs_info *regs_info = get_regs_info ();
- if (regno == -1)
- {
- if (regs_info->usrregs != NULL)
- for (regno = 0; regno < regs_info->usrregs->num_regs; regno++)
- low_fetch_register (regcache, regno);
- all = regsets_fetch_inferior_registers (regs_info->regsets_info, regcache);
- if (regs_info->usrregs != NULL)
- usr_fetch_inferior_registers (regs_info, regcache, -1, all);
- }
- else
- {
- if (low_fetch_register (regcache, regno))
- return;
- use_regsets = linux_register_in_regsets (regs_info, regno);
- if (use_regsets)
- all = regsets_fetch_inferior_registers (regs_info->regsets_info,
- regcache);
- if ((!use_regsets || all) && regs_info->usrregs != NULL)
- usr_fetch_inferior_registers (regs_info, regcache, regno, 1);
- }
- }
- void
- linux_process_target::store_registers (regcache *regcache, int regno)
- {
- int use_regsets;
- int all = 0;
- const regs_info *regs_info = get_regs_info ();
- if (regno == -1)
- {
- all = regsets_store_inferior_registers (regs_info->regsets_info,
- regcache);
- if (regs_info->usrregs != NULL)
- usr_store_inferior_registers (regs_info, regcache, regno, all);
- }
- else
- {
- use_regsets = linux_register_in_regsets (regs_info, regno);
- if (use_regsets)
- all = regsets_store_inferior_registers (regs_info->regsets_info,
- regcache);
- if ((!use_regsets || all) && regs_info->usrregs != NULL)
- usr_store_inferior_registers (regs_info, regcache, regno, 1);
- }
- }
- bool
- linux_process_target::low_fetch_register (regcache *regcache, int regno)
- {
- return false;
- }
- /* A wrapper for the read_memory target op. */
- static int
- linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
- {
- return the_target->read_memory (memaddr, myaddr, len);
- }
- /* Copy LEN bytes from inferior's memory starting at MEMADDR
- to debugger memory starting at MYADDR. */
- int
- linux_process_target::read_memory (CORE_ADDR memaddr,
- unsigned char *myaddr, int len)
- {
- int pid = lwpid_of (current_thread);
- PTRACE_XFER_TYPE *buffer;
- CORE_ADDR addr;
- int count;
- char filename[64];
- int i;
- int ret;
- int fd;
- /* Try using /proc. Don't bother for one word. */
- if (len >= 3 * sizeof (long))
- {
- int bytes;
- /* We could keep this file open and cache it - possibly one per
- thread. That requires some juggling, but is even faster. */
- sprintf (filename, "/proc/%d/mem", pid);
- fd = open (filename, O_RDONLY | O_LARGEFILE);
- if (fd == -1)
- goto no_proc;
- /* If pread64 is available, use it. It's faster if the kernel
- supports it (only one syscall), and it's 64-bit safe even on
- 32-bit platforms (for instance, SPARC debugging a SPARC64
- application). */
- #ifdef HAVE_PREAD64
- bytes = pread64 (fd, myaddr, len, memaddr);
- #else
- bytes = -1;
- if (lseek (fd, memaddr, SEEK_SET) != -1)
- bytes = read (fd, myaddr, len);
- #endif
- close (fd);
- if (bytes == len)
- return 0;
- /* Some data was read, we'll try to get the rest with ptrace. */
- if (bytes > 0)
- {
- memaddr += bytes;
- myaddr += bytes;
- len -= bytes;
- }
- }
- no_proc:
- /* Round starting address down to longword boundary. */
- addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
- /* Round ending address up; get number of longwords that makes. */
- count = ((((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
- / sizeof (PTRACE_XFER_TYPE));
- /* Allocate buffer of that many longwords. */
- buffer = XALLOCAVEC (PTRACE_XFER_TYPE, count);
- /* Read all the longwords */
- errno = 0;
- for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
- {
- /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
- about coercing an 8 byte integer to a 4 byte pointer. */
- buffer[i] = ptrace (PTRACE_PEEKTEXT, pid,
- (PTRACE_TYPE_ARG3) (uintptr_t) addr,
- (PTRACE_TYPE_ARG4) 0);
- if (errno)
- break;
- }
- ret = errno;
- /* Copy appropriate bytes out of the buffer. */
- if (i > 0)
- {
- i *= sizeof (PTRACE_XFER_TYPE);
- i -= memaddr & (sizeof (PTRACE_XFER_TYPE) - 1);
- memcpy (myaddr,
- (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
- i < len ? i : len);
- }
- return ret;
- }
- /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
- memory at MEMADDR. On failure (cannot write to the inferior)
- returns the value of errno. Always succeeds if LEN is zero. */
- int
- linux_process_target::write_memory (CORE_ADDR memaddr,
- const unsigned char *myaddr, int len)
- {
- int i;
- /* Round starting address down to longword boundary. */
- CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
- /* Round ending address up; get number of longwords that makes. */
- int count
- = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
- / sizeof (PTRACE_XFER_TYPE);
- /* Allocate buffer of that many longwords. */
- PTRACE_XFER_TYPE *buffer = XALLOCAVEC (PTRACE_XFER_TYPE, count);
- int pid = lwpid_of (current_thread);
- if (len == 0)
- {
- /* Zero length write always succeeds. */
- return 0;
- }
- if (debug_threads)
- {
- /* Dump up to four bytes. */
- char str[4 * 2 + 1];
- char *p = str;
- int dump = len < 4 ? len : 4;
- for (i = 0; i < dump; i++)
- {
- sprintf (p, "%02x", myaddr[i]);
- p += 2;
- }
- *p = '\0';
- threads_debug_printf ("Writing %s to 0x%08lx in process %d",
- str, (long) memaddr, pid);
- }
- /* Fill start and end extra bytes of buffer with existing memory data. */
- errno = 0;
- /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
- about coercing an 8 byte integer to a 4 byte pointer. */
- buffer[0] = ptrace (PTRACE_PEEKTEXT, pid,
- (PTRACE_TYPE_ARG3) (uintptr_t) addr,
- (PTRACE_TYPE_ARG4) 0);
- if (errno)
- return errno;
- if (count > 1)
- {
- errno = 0;
- buffer[count - 1]
- = ptrace (PTRACE_PEEKTEXT, pid,
- /* Coerce to a uintptr_t first to avoid potential gcc warning
- about coercing an 8 byte integer to a 4 byte pointer. */
- (PTRACE_TYPE_ARG3) (uintptr_t) (addr + (count - 1)
- * sizeof (PTRACE_XFER_TYPE)),
- (PTRACE_TYPE_ARG4) 0);
- if (errno)
- return errno;
- }
- /* Copy data to be written over corresponding part of buffer. */
- memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
- myaddr, len);
- /* Write the entire buffer. */
- for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
- {
- errno = 0;
- ptrace (PTRACE_POKETEXT, pid,
- /* Coerce to a uintptr_t first to avoid potential gcc warning
- about coercing an 8 byte integer to a 4 byte pointer. */
- (PTRACE_TYPE_ARG3) (uintptr_t) addr,
- (PTRACE_TYPE_ARG4) buffer[i]);
- if (errno)
- return errno;
- }
- return 0;
- }
- void
- linux_process_target::look_up_symbols ()
- {
- #ifdef USE_THREAD_DB
- struct process_info *proc = current_process ();
- if (proc->priv->thread_db != NULL)
- return;
- thread_db_init ();
- #endif
- }
- void
- linux_process_target::request_interrupt ()
- {
- /* Send a SIGINT to the process group. This acts just like the user
- typed a ^C on the controlling terminal. */
- ::kill (-signal_pid, SIGINT);
- }
- bool
- linux_process_target::supports_read_auxv ()
- {
- return true;
- }
- /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
- to debugger memory starting at MYADDR. */
- int
- linux_process_target::read_auxv (CORE_ADDR offset, unsigned char *myaddr,
- unsigned int len)
- {
- char filename[PATH_MAX];
- int fd, n;
- int pid = lwpid_of (current_thread);
- xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
- fd = open (filename, O_RDONLY);
- if (fd < 0)
- return -1;
- if (offset != (CORE_ADDR) 0
- && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
- n = -1;
- else
- n = read (fd, myaddr, len);
- close (fd);
- return n;
- }
- int
- linux_process_target::insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
- int size, raw_breakpoint *bp)
- {
- if (type == raw_bkpt_type_sw)
- return insert_memory_breakpoint (bp);
- else
- return low_insert_point (type, addr, size, bp);
- }
- int
- linux_process_target::low_insert_point (raw_bkpt_type type, CORE_ADDR addr,
- int size, raw_breakpoint *bp)
- {
- /* Unsupported (see target.h). */
- return 1;
- }
- int
- linux_process_target::remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
- int size, raw_breakpoint *bp)
- {
- if (type == raw_bkpt_type_sw)
- return remove_memory_breakpoint (bp);
- else
- return low_remove_point (type, addr, size, bp);
- }
- int
- linux_process_target::low_remove_point (raw_bkpt_type type, CORE_ADDR addr,
- int size, raw_breakpoint *bp)
- {
- /* Unsupported (see target.h). */
- return 1;
- }
- /* Implement the stopped_by_sw_breakpoint target_ops
- method. */
- bool
- linux_process_target::stopped_by_sw_breakpoint ()
- {
- struct lwp_info *lwp = get_thread_lwp (current_thread);
- return (lwp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT);
- }
- /* Implement the supports_stopped_by_sw_breakpoint target_ops
- method. */
- bool
- linux_process_target::supports_stopped_by_sw_breakpoint ()
- {
- return USE_SIGTRAP_SIGINFO;
- }
- /* Implement the stopped_by_hw_breakpoint target_ops
- method. */
- bool
- linux_process_target::stopped_by_hw_breakpoint ()
- {
- struct lwp_info *lwp = get_thread_lwp (current_thread);
- return (lwp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT);
- }
- /* Implement the supports_stopped_by_hw_breakpoint target_ops
- method. */
- bool
- linux_process_target::supports_stopped_by_hw_breakpoint ()
- {
- return USE_SIGTRAP_SIGINFO;
- }
- /* Implement the supports_hardware_single_step target_ops method. */
- bool
- linux_process_target::supports_hardware_single_step ()
- {
- return true;
- }
- bool
- linux_process_target::stopped_by_watchpoint ()
- {
- struct lwp_info *lwp = get_thread_lwp (current_thread);
- return lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
- }
- CORE_ADDR
- linux_process_target::stopped_data_address ()
- {
- struct lwp_info *lwp = get_thread_lwp (current_thread);
- return lwp->stopped_data_address;
- }
- /* This is only used for targets that define PT_TEXT_ADDR,
- PT_DATA_ADDR and PT_TEXT_END_ADDR. If those are not defined, supposedly
- the target has different ways of acquiring this information, like
- loadmaps. */
- bool
- linux_process_target::supports_read_offsets ()
- {
- #ifdef SUPPORTS_READ_OFFSETS
- return true;
- #else
- return false;
- #endif
- }
- /* Under uClinux, programs are loaded at non-zero offsets, which we need
- to tell gdb about. */
- int
- linux_process_target::read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
- {
- #ifdef SUPPORTS_READ_OFFSETS
- unsigned long text, text_end, data;
- int pid = lwpid_of (current_thread);
- errno = 0;
- text = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_TEXT_ADDR,
- (PTRACE_TYPE_ARG4) 0);
- text_end = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_TEXT_END_ADDR,
- (PTRACE_TYPE_ARG4) 0);
- data = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_DATA_ADDR,
- (PTRACE_TYPE_ARG4) 0);
- if (errno == 0)
- {
- /* Both text and data offsets produced at compile-time (and so
- used by gdb) are relative to the beginning of the program,
- with the data segment immediately following the text segment.
- However, the actual runtime layout in memory may put the data
- somewhere else, so when we send gdb a data base-address, we
- use the real data base address and subtract the compile-time
- data base-address from it (which is just the length of the
- text segment). BSS immediately follows data in both
- cases. */
- *text_p = text;
- *data_p = data - (text_end - text);
- return 1;
- }
- return 0;
- #else
- gdb_assert_not_reached ("target op read_offsets not supported");
- #endif
- }
- bool
- linux_process_target::supports_get_tls_address ()
- {
- #ifdef USE_THREAD_DB
- return true;
- #else
- return false;
- #endif
- }
- int
- linux_process_target::get_tls_address (thread_info *thread,
- CORE_ADDR offset,
- CORE_ADDR load_module,
- CORE_ADDR *address)
- {
- #ifdef USE_THREAD_DB
- return thread_db_get_tls_address (thread, offset, load_module, address);
- #else
- return -1;
- #endif
- }
- bool
- linux_process_target::supports_qxfer_osdata ()
- {
- return true;
- }
- int
- linux_process_target::qxfer_osdata (const char *annex,
- unsigned char *readbuf,
- unsigned const char *writebuf,
- CORE_ADDR offset, int len)
- {
- return linux_common_xfer_osdata (annex, readbuf, offset, len);
- }
- void
- linux_process_target::siginfo_fixup (siginfo_t *siginfo,
- gdb_byte *inf_siginfo, int direction)
- {
- bool done = low_siginfo_fixup (siginfo, inf_siginfo, direction);
- /* If there was no callback, or the callback didn't do anything,
- then just do a straight memcpy. */
- if (!done)
- {
- if (direction == 1)
- memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
- else
- memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
- }
- }
- bool
- linux_process_target::low_siginfo_fixup (siginfo_t *native, gdb_byte *inf,
- int direction)
- {
- return false;
- }
- bool
- linux_process_target::supports_qxfer_siginfo ()
- {
- return true;
- }
- int
- linux_process_target::qxfer_siginfo (const char *annex,
- unsigned char *readbuf,
- unsigned const char *writebuf,
- CORE_ADDR offset, int len)
- {
- int pid;
- siginfo_t siginfo;
- gdb_byte inf_siginfo[sizeof (siginfo_t)];
- if (current_thread == NULL)
- return -1;
- pid = lwpid_of (current_thread);
- threads_debug_printf ("%s siginfo for lwp %d.",
- readbuf != NULL ? "Reading" : "Writing",
- pid);
- if (offset >= sizeof (siginfo))
- return -1;
- if (ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo) != 0)
- return -1;
- /* When GDBSERVER is built as a 64-bit application, ptrace writes into
- SIGINFO an object with 64-bit layout. Since debugging a 32-bit
- inferior with a 64-bit GDBSERVER should look the same as debugging it
- with a 32-bit GDBSERVER, we need to convert it. */
- siginfo_fixup (&siginfo, inf_siginfo, 0);
- if (offset + len > sizeof (siginfo))
- len = sizeof (siginfo) - offset;
- if (readbuf != NULL)
- memcpy (readbuf, inf_siginfo + offset, len);
- else
- {
- memcpy (inf_siginfo + offset, writebuf, len);
- /* Convert back to ptrace layout before flushing it out. */
- siginfo_fixup (&siginfo, inf_siginfo, 1);
- if (ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo) != 0)
- return -1;
- }
- return len;
- }
- /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
- so we notice when children change state; as the handler for the
- sigsuspend in my_waitpid. */
- static void
- sigchld_handler (int signo)
- {
- int old_errno = errno;
- if (debug_threads)
- {
- do
- {
- /* Use the async signal safe debug function. */
- if (debug_write ("sigchld_handler\n",
- sizeof ("sigchld_handler\n") - 1) < 0)
- break; /* just ignore */
- } while (0);
- }
- if (target_is_async_p ())
- async_file_mark (); /* trigger a linux_wait */
- errno = old_errno;
- }
- bool
- linux_process_target::supports_non_stop ()
- {
- return true;
- }
- bool
- linux_process_target::async (bool enable)
- {
- bool previous = target_is_async_p ();
- threads_debug_printf ("async (%d), previous=%d",
- enable, previous);
- if (previous != enable)
- {
- sigset_t mask;
- sigemptyset (&mask);
- sigaddset (&mask, SIGCHLD);
- gdb_sigmask (SIG_BLOCK, &mask, NULL);
- if (enable)
- {
- if (!linux_event_pipe.open_pipe ())
- {
- gdb_sigmask (SIG_UNBLOCK, &mask, NULL);
- warning ("creating event pipe failed.");
- return previous;
- }
- /* Register the event loop handler. */
- add_file_handler (linux_event_pipe.event_fd (),
- handle_target_event, NULL,
- "linux-low");
- /* Always trigger a linux_wait. */
- async_file_mark ();
- }
- else
- {
- delete_file_handler (linux_event_pipe.event_fd ());
- linux_event_pipe.close_pipe ();
- }
- gdb_sigmask (SIG_UNBLOCK, &mask, NULL);
- }
- return previous;
- }
- int
- linux_process_target::start_non_stop (bool nonstop)
- {
- /* Register or unregister from event-loop accordingly. */
- target_async (nonstop);
- if (target_is_async_p () != (nonstop != false))
- return -1;
- return 0;
- }
- bool
- linux_process_target::supports_multi_process ()
- {
- return true;
- }
- /* Check if fork events are supported. */
- bool
- linux_process_target::supports_fork_events ()
- {
- return true;
- }
- /* Check if vfork events are supported. */
- bool
- linux_process_target::supports_vfork_events ()
- {
- return true;
- }
- /* Check if exec events are supported. */
- bool
- linux_process_target::supports_exec_events ()
- {
- return true;
- }
- /* Target hook for 'handle_new_gdb_connection'. Causes a reset of the
- ptrace flags for all inferiors. This is in case the new GDB connection
- doesn't support the same set of events that the previous one did. */
- void
- linux_process_target::handle_new_gdb_connection ()
- {
- /* Request that all the lwps reset their ptrace options. */
- for_each_thread ([] (thread_info *thread)
- {
- struct lwp_info *lwp = get_thread_lwp (thread);
- if (!lwp->stopped)
- {
- /* Stop the lwp so we can modify its ptrace options. */
- lwp->must_set_ptrace_flags = 1;
- linux_stop_lwp (lwp);
- }
- else
- {
- /* Already stopped; go ahead and set the ptrace options. */
- struct process_info *proc = find_process_pid (pid_of (thread));
- int options = linux_low_ptrace_options (proc->attached);
- linux_enable_event_reporting (lwpid_of (thread), options);
- lwp->must_set_ptrace_flags = 0;
- }
- });
- }
- int
- linux_process_target::handle_monitor_command (char *mon)
- {
- #ifdef USE_THREAD_DB
- return thread_db_handle_monitor_command (mon);
- #else
- return 0;
- #endif
- }
- int
- linux_process_target::core_of_thread (ptid_t ptid)
- {
- return linux_common_core_of_thread (ptid);
- }
- bool
- linux_process_target::supports_disable_randomization ()
- {
- return true;
- }
- bool
- linux_process_target::supports_agent ()
- {
- return true;
- }
- bool
- linux_process_target::supports_range_stepping ()
- {
- if (supports_software_single_step ())
- return true;
- return low_supports_range_stepping ();
- }
- bool
- linux_process_target::low_supports_range_stepping ()
- {
- return false;
- }
- bool
- linux_process_target::supports_pid_to_exec_file ()
- {
- return true;
- }
- const char *
- linux_process_target::pid_to_exec_file (int pid)
- {
- return linux_proc_pid_to_exec_file (pid);
- }
- bool
- linux_process_target::supports_multifs ()
- {
- return true;
- }
- int
- linux_process_target::multifs_open (int pid, const char *filename,
- int flags, mode_t mode)
- {
- return linux_mntns_open_cloexec (pid, filename, flags, mode);
- }
- int
- linux_process_target::multifs_unlink (int pid, const char *filename)
- {
- return linux_mntns_unlink (pid, filename);
- }
- ssize_t
- linux_process_target::multifs_readlink (int pid, const char *filename,
- char *buf, size_t bufsiz)
- {
- return linux_mntns_readlink (pid, filename, buf, bufsiz);
- }
- #if defined PT_GETDSBT || defined PTRACE_GETFDPIC
- struct target_loadseg
- {
- /* Core address to which the segment is mapped. */
- Elf32_Addr addr;
- /* VMA recorded in the program header. */
- Elf32_Addr p_vaddr;
- /* Size of this segment in memory. */
- Elf32_Word p_memsz;
- };
- # if defined PT_GETDSBT
- struct target_loadmap
- {
- /* Protocol version number, must be zero. */
- Elf32_Word version;
- /* Pointer to the DSBT table, its size, and the DSBT index. */
- unsigned *dsbt_table;
- unsigned dsbt_size, dsbt_index;
- /* Number of segments in this map. */
- Elf32_Word nsegs;
- /* The actual memory map. */
- struct target_loadseg segs[/*nsegs*/];
- };
- # define LINUX_LOADMAP PT_GETDSBT
- # define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
- # define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
- # else
- struct target_loadmap
- {
- /* Protocol version number, must be zero. */
- Elf32_Half version;
- /* Number of segments in this map. */
- Elf32_Half nsegs;
- /* The actual memory map. */
- struct target_loadseg segs[/*nsegs*/];
- };
- # define LINUX_LOADMAP PTRACE_GETFDPIC
- # define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
- # define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
- # endif
- bool
- linux_process_target::supports_read_loadmap ()
- {
- return true;
- }
- int
- linux_process_target::read_loadmap (const char *annex, CORE_ADDR offset,
- unsigned char *myaddr, unsigned int len)
- {
- int pid = lwpid_of (current_thread);
- int addr = -1;
- struct target_loadmap *data = NULL;
- unsigned int actual_length, copy_length;
- if (strcmp (annex, "exec") == 0)
- addr = (int) LINUX_LOADMAP_EXEC;
- else if (strcmp (annex, "interp") == 0)
- addr = (int) LINUX_LOADMAP_INTERP;
- else
- return -1;
- if (ptrace (LINUX_LOADMAP, pid, addr, &data) != 0)
- return -1;
- if (data == NULL)
- return -1;
- actual_length = sizeof (struct target_loadmap)
- + sizeof (struct target_loadseg) * data->nsegs;
- if (offset < 0 || offset > actual_length)
- return -1;
- copy_length = actual_length - offset < len ? actual_length - offset : len;
- memcpy (myaddr, (char *) data + offset, copy_length);
- return copy_length;
- }
- #endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
- bool
- linux_process_target::supports_catch_syscall ()
- {
- return low_supports_catch_syscall ();
- }
- bool
- linux_process_target::low_supports_catch_syscall ()
- {
- return false;
- }
- CORE_ADDR
- linux_process_target::read_pc (regcache *regcache)
- {
- if (!low_supports_breakpoints ())
- return 0;
- return low_get_pc (regcache);
- }
- void
- linux_process_target::write_pc (regcache *regcache, CORE_ADDR pc)
- {
- gdb_assert (low_supports_breakpoints ());
- low_set_pc (regcache, pc);
- }
- bool
- linux_process_target::supports_thread_stopped ()
- {
- return true;
- }
- bool
- linux_process_target::thread_stopped (thread_info *thread)
- {
- return get_thread_lwp (thread)->stopped;
- }
- /* This exposes stop-all-threads functionality to other modules. */
- void
- linux_process_target::pause_all (bool freeze)
- {
- stop_all_lwps (freeze, NULL);
- }
- /* This exposes unstop-all-threads functionality to other gdbserver
- modules. */
- void
- linux_process_target::unpause_all (bool unfreeze)
- {
- unstop_all_lwps (unfreeze, NULL);
- }
- int
- linux_process_target::prepare_to_access_memory ()
- {
- /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
- running LWP. */
- if (non_stop)
- target_pause_all (true);
- return 0;
- }
- void
- linux_process_target::done_accessing_memory ()
- {
- /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
- running LWP. */
- if (non_stop)
- target_unpause_all (true);
- }
- /* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
- static int
- get_phdr_phnum_from_proc_auxv (const int pid, const int is_elf64,
- CORE_ADDR *phdr_memaddr, int *num_phdr)
- {
- char filename[PATH_MAX];
- int fd;
- const int auxv_size = is_elf64
- ? sizeof (Elf64_auxv_t) : sizeof (Elf32_auxv_t);
- char buf[sizeof (Elf64_auxv_t)]; /* The larger of the two. */
- xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
- fd = open (filename, O_RDONLY);
- if (fd < 0)
- return 1;
- *phdr_memaddr = 0;
- *num_phdr = 0;
- while (read (fd, buf, auxv_size) == auxv_size
- && (*phdr_memaddr == 0 || *num_phdr == 0))
- {
- if (is_elf64)
- {
- Elf64_auxv_t *const aux = (Elf64_auxv_t *) buf;
- switch (aux->a_type)
- {
- case AT_PHDR:
- *phdr_memaddr = aux->a_un.a_val;
- break;
- case AT_PHNUM:
- *num_phdr = aux->a_un.a_val;
- break;
- }
- }
- else
- {
- Elf32_auxv_t *const aux = (Elf32_auxv_t *) buf;
- switch (aux->a_type)
- {
- case AT_PHDR:
- *phdr_memaddr = aux->a_un.a_val;
- break;
- case AT_PHNUM:
- *num_phdr = aux->a_un.a_val;
- break;
- }
- }
- }
- close (fd);
- if (*phdr_memaddr == 0 || *num_phdr == 0)
- {
- warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
- "phdr_memaddr = %ld, phdr_num = %d",
- (long) *phdr_memaddr, *num_phdr);
- return 2;
- }
- return 0;
- }
- /* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
- static CORE_ADDR
- get_dynamic (const int pid, const int is_elf64)
- {
- CORE_ADDR phdr_memaddr, relocation;
- int num_phdr, i;
- unsigned char *phdr_buf;
- const int phdr_size = is_elf64 ? sizeof (Elf64_Phdr) : sizeof (Elf32_Phdr);
- if (get_phdr_phnum_from_proc_auxv (pid, is_elf64, &phdr_memaddr, &num_phdr))
- return 0;
- gdb_assert (num_phdr < 100); /* Basic sanity check. */
- phdr_buf = (unsigned char *) alloca (num_phdr * phdr_size);
- if (linux_read_memory (phdr_memaddr, phdr_buf, num_phdr * phdr_size))
- return 0;
- /* Compute relocation: it is expected to be 0 for "regular" executables,
- non-zero for PIE ones. */
- relocation = -1;
- for (i = 0; relocation == -1 && i < num_phdr; i++)
- if (is_elf64)
- {
- Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
- if (p->p_type == PT_PHDR)
- relocation = phdr_memaddr - p->p_vaddr;
- }
- else
- {
- Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
- if (p->p_type == PT_PHDR)
- relocation = phdr_memaddr - p->p_vaddr;
- }
- if (relocation == -1)
- {
- /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
- any real world executables, including PIE executables, have always
- PT_PHDR present. PT_PHDR is not present in some shared libraries or
- in fpc (Free Pascal 2.4) binaries but neither of those have a need for
- or present DT_DEBUG anyway (fpc binaries are statically linked).
- Therefore if there exists DT_DEBUG there is always also PT_PHDR.
- GDB could find RELOCATION also from AT_ENTRY - e_entry. */
- return 0;
- }
- for (i = 0; i < num_phdr; i++)
- {
- if (is_elf64)
- {
- Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
- if (p->p_type == PT_DYNAMIC)
- return p->p_vaddr + relocation;
- }
- else
- {
- Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
- if (p->p_type == PT_DYNAMIC)
- return p->p_vaddr + relocation;
- }
- }
- return 0;
- }
- /* Return &_r_debug in the inferior, or -1 if not present. Return value
- can be 0 if the inferior does not yet have the library list initialized.
- We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
- DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
- static CORE_ADDR
- get_r_debug (const int pid, const int is_elf64)
- {
- CORE_ADDR dynamic_memaddr;
- const int dyn_size = is_elf64 ? sizeof (Elf64_Dyn) : sizeof (Elf32_Dyn);
- unsigned char buf[sizeof (Elf64_Dyn)]; /* The larger of the two. */
- CORE_ADDR map = -1;
- dynamic_memaddr = get_dynamic (pid, is_elf64);
- if (dynamic_memaddr == 0)
- return map;
- while (linux_read_memory (dynamic_memaddr, buf, dyn_size) == 0)
- {
- if (is_elf64)
- {
- Elf64_Dyn *const dyn = (Elf64_Dyn *) buf;
- #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
- union
- {
- Elf64_Xword map;
- unsigned char buf[sizeof (Elf64_Xword)];
- }
- rld_map;
- #endif
- #ifdef DT_MIPS_RLD_MAP
- if (dyn->d_tag == DT_MIPS_RLD_MAP)
- {
- if (linux_read_memory (dyn->d_un.d_val,
- rld_map.buf, sizeof (rld_map.buf)) == 0)
- return rld_map.map;
- else
- break;
- }
- #endif /* DT_MIPS_RLD_MAP */
- #ifdef DT_MIPS_RLD_MAP_REL
- if (dyn->d_tag == DT_MIPS_RLD_MAP_REL)
- {
- if (linux_read_memory (dyn->d_un.d_val + dynamic_memaddr,
- rld_map.buf, sizeof (rld_map.buf)) == 0)
- return rld_map.map;
- else
- break;
- }
- #endif /* DT_MIPS_RLD_MAP_REL */
- if (dyn->d_tag == DT_DEBUG && map == -1)
- map = dyn->d_un.d_val;
- if (dyn->d_tag == DT_NULL)
- break;
- }
- else
- {
- Elf32_Dyn *const dyn = (Elf32_Dyn *) buf;
- #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
- union
- {
- Elf32_Word map;
- unsigned char buf[sizeof (Elf32_Word)];
- }
- rld_map;
- #endif
- #ifdef DT_MIPS_RLD_MAP
- if (dyn->d_tag == DT_MIPS_RLD_MAP)
- {
- if (linux_read_memory (dyn->d_un.d_val,
- rld_map.buf, sizeof (rld_map.buf)) == 0)
- return rld_map.map;
- else
- break;
- }
- #endif /* DT_MIPS_RLD_MAP */
- #ifdef DT_MIPS_RLD_MAP_REL
- if (dyn->d_tag == DT_MIPS_RLD_MAP_REL)
- {
- if (linux_read_memory (dyn->d_un.d_val + dynamic_memaddr,
- rld_map.buf, sizeof (rld_map.buf)) == 0)
- return rld_map.map;
- else
- break;
- }
- #endif /* DT_MIPS_RLD_MAP_REL */
- if (dyn->d_tag == DT_DEBUG && map == -1)
- map = dyn->d_un.d_val;
- if (dyn->d_tag == DT_NULL)
- break;
- }
- dynamic_memaddr += dyn_size;
- }
- return map;
- }
- /* Read one pointer from MEMADDR in the inferior. */
- static int
- read_one_ptr (CORE_ADDR memaddr, CORE_ADDR *ptr, int ptr_size)
- {
- int ret;
- /* Go through a union so this works on either big or little endian
- hosts, when the inferior's pointer size is smaller than the size
- of CORE_ADDR. It is assumed the inferior's endianness is the
- same of the superior's. */
- union
- {
- CORE_ADDR core_addr;
- unsigned int ui;
- unsigned char uc;
- } addr;
- ret = linux_read_memory (memaddr, &addr.uc, ptr_size);
- if (ret == 0)
- {
- if (ptr_size == sizeof (CORE_ADDR))
- *ptr = addr.core_addr;
- else if (ptr_size == sizeof (unsigned int))
- *ptr = addr.ui;
- else
- gdb_assert_not_reached ("unhandled pointer size");
- }
- return ret;
- }
- bool
- linux_process_target::supports_qxfer_libraries_svr4 ()
- {
- return true;
- }
- struct link_map_offsets
- {
- /* Offset and size of r_debug.r_version. */
- int r_version_offset;
- /* Offset and size of r_debug.r_map. */
- int r_map_offset;
- /* Offset to l_addr field in struct link_map. */
- int l_addr_offset;
- /* Offset to l_name field in struct link_map. */
- int l_name_offset;
- /* Offset to l_ld field in struct link_map. */
- int l_ld_offset;
- /* Offset to l_next field in struct link_map. */
- int l_next_offset;
- /* Offset to l_prev field in struct link_map. */
- int l_prev_offset;
- };
- /* Construct qXfer:libraries-svr4:read reply. */
- int
- linux_process_target::qxfer_libraries_svr4 (const char *annex,
- unsigned char *readbuf,
- unsigned const char *writebuf,
- CORE_ADDR offset, int len)
- {
- struct process_info_private *const priv = current_process ()->priv;
- char filename[PATH_MAX];
- int pid, is_elf64;
- static const struct link_map_offsets lmo_32bit_offsets =
- {
- 0, /* r_version offset. */
- 4, /* r_debug.r_map offset. */
- 0, /* l_addr offset in link_map. */
- 4, /* l_name offset in link_map. */
- 8, /* l_ld offset in link_map. */
- 12, /* l_next offset in link_map. */
- 16 /* l_prev offset in link_map. */
- };
- static const struct link_map_offsets lmo_64bit_offsets =
- {
- 0, /* r_version offset. */
- 8, /* r_debug.r_map offset. */
- 0, /* l_addr offset in link_map. */
- 8, /* l_name offset in link_map. */
- 16, /* l_ld offset in link_map. */
- 24, /* l_next offset in link_map. */
- 32 /* l_prev offset in link_map. */
- };
- const struct link_map_offsets *lmo;
- unsigned int machine;
- int ptr_size;
- CORE_ADDR lm_addr = 0, lm_prev = 0;
- CORE_ADDR l_name, l_addr, l_ld, l_next, l_prev;
- int header_done = 0;
- if (writebuf != NULL)
- return -2;
- if (readbuf == NULL)
- return -1;
- pid = lwpid_of (current_thread);
- xsnprintf (filename, sizeof filename, "/proc/%d/exe", pid);
- is_elf64 = elf_64_file_p (filename, &machine);
- lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets;
- ptr_size = is_elf64 ? 8 : 4;
- while (annex[0] != '\0')
- {
- const char *sep;
- CORE_ADDR *addrp;
- int name_len;
- sep = strchr (annex, '=');
- if (sep == NULL)
- break;
- name_len = sep - annex;
- if (name_len == 5 && startswith (annex, "start"))
- addrp = &lm_addr;
- else if (name_len == 4 && startswith (annex, "prev"))
- addrp = &lm_prev;
- else
- {
- annex = strchr (sep, ';');
- if (annex == NULL)
- break;
- annex++;
- continue;
- }
- annex = decode_address_to_semicolon (addrp, sep + 1);
- }
- if (lm_addr == 0)
- {
- int r_version = 0;
- if (priv->r_debug == 0)
- priv->r_debug = get_r_debug (pid, is_elf64);
- /* We failed to find DT_DEBUG. Such situation will not change
- for this inferior - do not retry it. Report it to GDB as
- E01, see for the reasons at the GDB solib-svr4.c side. */
- if (priv->r_debug == (CORE_ADDR) -1)
- return -1;
- if (priv->r_debug != 0)
- {
- if (linux_read_memory (priv->r_debug + lmo->r_version_offset,
- (unsigned char *) &r_version,
- sizeof (r_version)) != 0
- || r_version < 1)
- {
- warning ("unexpected r_debug version %d", r_version);
- }
- else if (read_one_ptr (priv->r_debug + lmo->r_map_offset,
- &lm_addr, ptr_size) != 0)
- {
- warning ("unable to read r_map from 0x%lx",
- (long) priv->r_debug + lmo->r_map_offset);
- }
- }
- }
- std::string document = "<library-list-svr4 version=\"1.0\"";
- while (lm_addr
- && read_one_ptr (lm_addr + lmo->l_name_offset,
- &l_name, ptr_size) == 0
- && read_one_ptr (lm_addr + lmo->l_addr_offset,
- &l_addr, ptr_size) == 0
- && read_one_ptr (lm_addr + lmo->l_ld_offset,
- &l_ld, ptr_size) == 0
- && read_one_ptr (lm_addr + lmo->l_prev_offset,
- &l_prev, ptr_size) == 0
- && read_one_ptr (lm_addr + lmo->l_next_offset,
- &l_next, ptr_size) == 0)
- {
- unsigned char libname[PATH_MAX];
- if (lm_prev != l_prev)
- {
- warning ("Corrupted shared library list: 0x%lx != 0x%lx",
- (long) lm_prev, (long) l_prev);
- break;
- }
- /* Ignore the first entry even if it has valid name as the first entry
- corresponds to the main executable. The first entry should not be
- skipped if the dynamic loader was loaded late by a static executable
- (see solib-svr4.c parameter ignore_first). But in such case the main
- executable does not have PT_DYNAMIC present and this function already
- exited above due to failed get_r_debug. */
- if (lm_prev == 0)
- string_appendf (document, " main-lm=\"0x%lx\"", (unsigned long) lm_addr);
- else
- {
- /* Not checking for error because reading may stop before
- we've got PATH_MAX worth of characters. */
- libname[0] = '\0';
- linux_read_memory (l_name, libname, sizeof (libname) - 1);
- libname[sizeof (libname) - 1] = '\0';
- if (libname[0] != '\0')
- {
- if (!header_done)
- {
- /* Terminate `<library-list-svr4'. */
- document += '>';
- header_done = 1;
- }
- string_appendf (document, "<library name=\"");
- xml_escape_text_append (&document, (char *) libname);
- string_appendf (document, "\" lm=\"0x%lx\" "
- "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
- (unsigned long) lm_addr, (unsigned long) l_addr,
- (unsigned long) l_ld);
- }
- }
- lm_prev = lm_addr;
- lm_addr = l_next;
- }
- if (!header_done)
- {
- /* Empty list; terminate `<library-list-svr4'. */
- document += "/>";
- }
- else
- document += "</library-list-svr4>";
- int document_len = document.length ();
- if (offset < document_len)
- document_len -= offset;
- else
- document_len = 0;
- if (len > document_len)
- len = document_len;
- memcpy (readbuf, document.data () + offset, len);
- return len;
- }
- #ifdef HAVE_LINUX_BTRACE
- btrace_target_info *
- linux_process_target::enable_btrace (thread_info *tp,
- const btrace_config *conf)
- {
- return linux_enable_btrace (tp->id, conf);
- }
- /* See to_disable_btrace target method. */
- int
- linux_process_target::disable_btrace (btrace_target_info *tinfo)
- {
- enum btrace_error err;
- err = linux_disable_btrace (tinfo);
- return (err == BTRACE_ERR_NONE ? 0 : -1);
- }
- /* Encode an Intel Processor Trace configuration. */
- static void
- linux_low_encode_pt_config (struct buffer *buffer,
- const struct btrace_data_pt_config *config)
- {
- buffer_grow_str (buffer, "<pt-config>\n");
- switch (config->cpu.vendor)
- {
- case CV_INTEL:
- buffer_xml_printf (buffer, "<cpu vendor=\"GenuineIntel\" family=\"%u\" "
- "model=\"%u\" stepping=\"%u\"/>\n",
- config->cpu.family, config->cpu.model,
- config->cpu.stepping);
- break;
- default:
- break;
- }
- buffer_grow_str (buffer, "</pt-config>\n");
- }
- /* Encode a raw buffer. */
- static void
- linux_low_encode_raw (struct buffer *buffer, const gdb_byte *data,
- unsigned int size)
- {
- if (size == 0)
- return;
- /* We use hex encoding - see gdbsupport/rsp-low.h. */
- buffer_grow_str (buffer, "<raw>\n");
- while (size-- > 0)
- {
- char elem[2];
- elem[0] = tohex ((*data >> 4) & 0xf);
- elem[1] = tohex (*data++ & 0xf);
- buffer_grow (buffer, elem, 2);
- }
- buffer_grow_str (buffer, "</raw>\n");
- }
- /* See to_read_btrace target method. */
- int
- linux_process_target::read_btrace (btrace_target_info *tinfo,
- buffer *buffer,
- enum btrace_read_type type)
- {
- struct btrace_data btrace;
- enum btrace_error err;
- err = linux_read_btrace (&btrace, tinfo, type);
- if (err != BTRACE_ERR_NONE)
- {
- if (err == BTRACE_ERR_OVERFLOW)
- buffer_grow_str0 (buffer, "E.Overflow.");
- else
- buffer_grow_str0 (buffer, "E.Generic Error.");
- return -1;
- }
- switch (btrace.format)
- {
- case BTRACE_FORMAT_NONE:
- buffer_grow_str0 (buffer, "E.No Trace.");
- return -1;
- case BTRACE_FORMAT_BTS:
- buffer_grow_str (buffer, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
- buffer_grow_str (buffer, "<btrace version=\"1.0\">\n");
- for (const btrace_block &block : *btrace.variant.bts.blocks)
- buffer_xml_printf (buffer, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
- paddress (block.begin), paddress (block.end));
- buffer_grow_str0 (buffer, "</btrace>\n");
- break;
- case BTRACE_FORMAT_PT:
- buffer_grow_str (buffer, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
- buffer_grow_str (buffer, "<btrace version=\"1.0\">\n");
- buffer_grow_str (buffer, "<pt>\n");
- linux_low_encode_pt_config (buffer, &btrace.variant.pt.config);
- linux_low_encode_raw (buffer, btrace.variant.pt.data,
- btrace.variant.pt.size);
- buffer_grow_str (buffer, "</pt>\n");
- buffer_grow_str0 (buffer, "</btrace>\n");
- break;
- default:
- buffer_grow_str0 (buffer, "E.Unsupported Trace Format.");
- return -1;
- }
- return 0;
- }
- /* See to_btrace_conf target method. */
- int
- linux_process_target::read_btrace_conf (const btrace_target_info *tinfo,
- buffer *buffer)
- {
- const struct btrace_config *conf;
- buffer_grow_str (buffer, "<!DOCTYPE btrace-conf SYSTEM \"btrace-conf.dtd\">\n");
- buffer_grow_str (buffer, "<btrace-conf version=\"1.0\">\n");
- conf = linux_btrace_conf (tinfo);
- if (conf != NULL)
- {
- switch (conf->format)
- {
- case BTRACE_FORMAT_NONE:
- break;
- case BTRACE_FORMAT_BTS:
- buffer_xml_printf (buffer, "<bts");
- buffer_xml_printf (buffer, " size=\"0x%x\"", conf->bts.size);
- buffer_xml_printf (buffer, " />\n");
- break;
- case BTRACE_FORMAT_PT:
- buffer_xml_printf (buffer, "<pt");
- buffer_xml_printf (buffer, " size=\"0x%x\"", conf->pt.size);
- buffer_xml_printf (buffer, "/>\n");
- break;
- }
- }
- buffer_grow_str0 (buffer, "</btrace-conf>\n");
- return 0;
- }
- #endif /* HAVE_LINUX_BTRACE */
- /* See nat/linux-nat.h. */
- ptid_t
- current_lwp_ptid (void)
- {
- return ptid_of (current_thread);
- }
- const char *
- linux_process_target::thread_name (ptid_t thread)
- {
- return linux_proc_tid_get_name (thread);
- }
- #if USE_THREAD_DB
- bool
- linux_process_target::thread_handle (ptid_t ptid, gdb_byte **handle,
- int *handle_len)
- {
- return thread_db_thread_handle (ptid, handle, handle_len);
- }
- #endif
- thread_info *
- linux_process_target::thread_pending_parent (thread_info *thread)
- {
- lwp_info *parent = get_thread_lwp (thread)->pending_parent ();
- if (parent == nullptr)
- return nullptr;
- return get_lwp_thread (parent);
- }
- thread_info *
- linux_process_target::thread_pending_child (thread_info *thread)
- {
- lwp_info *child = get_thread_lwp (thread)->pending_child ();
- if (child == nullptr)
- return nullptr;
- return get_lwp_thread (child);
- }
- /* Default implementation of linux_target_ops method "set_pc" for
- 32-bit pc register which is literally named "pc". */
- void
- linux_set_pc_32bit (struct regcache *regcache, CORE_ADDR pc)
- {
- uint32_t newpc = pc;
- supply_register_by_name (regcache, "pc", &newpc);
- }
- /* Default implementation of linux_target_ops method "get_pc" for
- 32-bit pc register which is literally named "pc". */
- CORE_ADDR
- linux_get_pc_32bit (struct regcache *regcache)
- {
- uint32_t pc;
- collect_register_by_name (regcache, "pc", &pc);
- threads_debug_printf ("stop pc is 0x%" PRIx32, pc);
- return pc;
- }
- /* Default implementation of linux_target_ops method "set_pc" for
- 64-bit pc register which is literally named "pc". */
- void
- linux_set_pc_64bit (struct regcache *regcache, CORE_ADDR pc)
- {
- uint64_t newpc = pc;
- supply_register_by_name (regcache, "pc", &newpc);
- }
- /* Default implementation of linux_target_ops method "get_pc" for
- 64-bit pc register which is literally named "pc". */
- CORE_ADDR
- linux_get_pc_64bit (struct regcache *regcache)
- {
- uint64_t pc;
- collect_register_by_name (regcache, "pc", &pc);
- threads_debug_printf ("stop pc is 0x%" PRIx64, pc);
- return pc;
- }
- /* See linux-low.h. */
- int
- linux_get_auxv (int wordsize, CORE_ADDR match, CORE_ADDR *valp)
- {
- gdb_byte *data = (gdb_byte *) alloca (2 * wordsize);
- int offset = 0;
- gdb_assert (wordsize == 4 || wordsize == 8);
- while (the_target->read_auxv (offset, data, 2 * wordsize) == 2 * wordsize)
- {
- if (wordsize == 4)
- {
- uint32_t *data_p = (uint32_t *) data;
- if (data_p[0] == match)
- {
- *valp = data_p[1];
- return 1;
- }
- }
- else
- {
- uint64_t *data_p = (uint64_t *) data;
- if (data_p[0] == match)
- {
- *valp = data_p[1];
- return 1;
- }
- }
- offset += 2 * wordsize;
- }
- return 0;
- }
- /* See linux-low.h. */
- CORE_ADDR
- linux_get_hwcap (int wordsize)
- {
- CORE_ADDR hwcap = 0;
- linux_get_auxv (wordsize, AT_HWCAP, &hwcap);
- return hwcap;
- }
- /* See linux-low.h. */
- CORE_ADDR
- linux_get_hwcap2 (int wordsize)
- {
- CORE_ADDR hwcap2 = 0;
- linux_get_auxv (wordsize, AT_HWCAP2, &hwcap2);
- return hwcap2;
- }
- #ifdef HAVE_LINUX_REGSETS
- void
- initialize_regsets_info (struct regsets_info *info)
- {
- for (info->num_regsets = 0;
- info->regsets[info->num_regsets].size >= 0;
- info->num_regsets++)
- ;
- }
- #endif
- void
- initialize_low (void)
- {
- struct sigaction sigchld_action;
- memset (&sigchld_action, 0, sizeof (sigchld_action));
- set_target_ops (the_linux_target);
- linux_ptrace_init_warnings ();
- linux_proc_init_warnings ();
- sigchld_action.sa_handler = sigchld_handler;
- sigemptyset (&sigchld_action.sa_mask);
- sigchld_action.sa_flags = SA_RESTART;
- sigaction (SIGCHLD, &sigchld_action, NULL);
- initialize_low_arch ();
- linux_check_ptrace_features ();
- }
|