Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133// SPDX-License-Identifier: GPL-2.0#include <errno.h>#include <signal.h>#include <inttypes.h>#include <linux/err.h>#include <linux/kernel.h>#include <linux/zalloc.h>#include <api/fs/fs.h>
#include <byteswap.h>#include <unistd.h>#include <sys/types.h>#include <sys/mman.h>#include <perf/cpumap.h>#include <perf/event.h>
#include "map_symbol.h"#include "branch.h"#include "debug.h"#include "dwarf-regs.h"#include "env.h"#include "evlist.h"#include "evsel.h"#include "memswap.h"#include "map.h"#include "symbol.h"#include "session.h"#include "tool.h"#include "perf_regs.h"#include "asm/bug.h"#include "auxtrace.h"#include "thread.h"#include "thread-stack.h"#include "sample-raw.h"#include "stat.h"#include "tsc.h"#include "ui/progress.h"#include "util.h"#include "arch/common.h"#include "units.h"#include "annotate.h"#include "perf.h"#include <internal/lib.h>
static int perf_session__deliver_event(struct perf_session *session, union perf_event *event, const struct perf_tool *tool, u64 file_offset, const char *file_path);
static int perf_session__open(struct perf_session *session){ struct perf_data *data = session->data;
if (perf_session__read_header(session) < 0) { pr_err("incompatible file format (rerun with -v to learn more)\n"); return -1; }
if (perf_header__has_feat(&session->header, HEADER_AUXTRACE)) { /* Auxiliary events may reference exited threads, hold onto dead ones. */ symbol_conf.keep_exited_threads = true; }
if (perf_data__is_pipe(data)) return 0;
if (perf_header__has_feat(&session->header, HEADER_STAT)) return 0;
if (!evlist__valid_sample_type(session->evlist)) { pr_err("non matching sample_type\n"); return -1; }
if (!evlist__valid_sample_id_all(session->evlist)) { pr_err("non matching sample_id_all\n"); return -1; }
if (!evlist__valid_read_format(session->evlist)) { pr_err("non matching read_format\n"); return -1; }
return 0;}
void perf_session__set_id_hdr_size(struct perf_session *session){ u16 id_hdr_size = evlist__id_hdr_size(session->evlist);
machines__set_id_hdr_size(&session->machines, id_hdr_size);}
int perf_session__create_kernel_maps(struct perf_session *session){ int ret = machine__create_kernel_maps(&session->machines.host);
if (ret >= 0) ret = machines__create_guest_kernel_maps(&session->machines); return ret;}
static void perf_session__destroy_kernel_maps(struct perf_session *session){ machines__destroy_kernel_maps(&session->machines);}
static bool perf_session__has_comm_exec(struct perf_session *session){ struct evsel *evsel;
evlist__for_each_entry(session->evlist, evsel) { if (evsel->core.attr.comm_exec) return true; }
return false;}
static void perf_session__set_comm_exec(struct perf_session *session){ bool comm_exec = perf_session__has_comm_exec(session);
machines__set_comm_exec(&session->machines, comm_exec);}
static int ordered_events__deliver_event(struct ordered_events *oe, struct ordered_event *event){ struct perf_session *session = container_of(oe, struct perf_session, ordered_events); int ret = perf_session__deliver_event(session, event->event, session->tool, event->file_offset, event->file_path);
if (ret) { pr_err("%#" PRIx64 " [%#x]: ordered event processing failed (%d) for event of type: %s (%d)\n", event->file_offset, event->event->header.size, ret, perf_event__name(event->event->header.type), event->event->header.type); } return ret;}
struct perf_session *__perf_session__new(struct perf_data *data, struct perf_tool *tool, bool trace_event_repipe, struct perf_env *host_env){ int ret = -ENOMEM; struct perf_session *session = zalloc(sizeof(*session));
if (!session) goto out;
session->trace_event_repipe = trace_event_repipe; session->tool = tool; session->decomp_data.zstd_decomp = &session->zstd_data; session->active_decomp = &session->decomp_data; INIT_LIST_HEAD(&session->auxtrace_index); perf_env__init(&session->header.env); if (machines__init(&session->machines)) goto out_delete;
ordered_events__init(&session->ordered_events, ordered_events__deliver_event, NULL); if (data) { ret = perf_data__open(data); if (ret < 0) goto out_delete;
session->data = data;
if (perf_data__is_read(data)) { ret = perf_session__open(session); if (ret < 0) goto out_delete;
/* * set session attributes that are present in perf.data * but not in pipe-mode. */ if (!data->is_pipe) { perf_session__set_id_hdr_size(session); perf_session__set_comm_exec(session); }
evlist__init_trace_event_sample_raw(session->evlist, &session->header.env);
/* Open the directory data. */ if (data->is_dir) { ret = perf_data__open_dir(data); if (ret) goto out_delete; }
if (!symbol_conf.kallsyms_name && !symbol_conf.vmlinux_name) symbol_conf.kallsyms_name = perf_data__kallsyms_name(data); } } else { assert(host_env != NULL); session->machines.host.env = host_env; } if (session->evlist) session->evlist->session = session;
session->machines.host.single_address_space = perf_env__single_address_space(session->machines.host.env);
if (!data || perf_data__is_write(data)) { /* * In O_RDONLY mode this will be performed when reading the * kernel MMAP event, in perf_event__process_mmap(). */ if (perf_session__create_kernel_maps(session) < 0) pr_warning("Cannot read kernel map\n"); }
/* * In pipe-mode, evlist is empty until PERF_RECORD_HEADER_ATTR is * processed, so evlist__sample_id_all is not meaningful here. */ if ((!data || !data->is_pipe) && tool && tool->ordering_requires_timestamps && tool->ordered_events && !evlist__sample_id_all(session->evlist)) { dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n"); tool->ordered_events = false; }
return session;
out_delete: perf_session__delete(session); out: return ERR_PTR(ret);}
static void perf_decomp__release_events(struct decomp *next){ struct decomp *decomp; size_t mmap_len;
do { decomp = next; if (decomp == NULL) break; next = decomp->next; mmap_len = decomp->mmap_len; munmap(decomp, mmap_len); } while (1);}
void perf_session__delete(struct perf_session *session){ if (session == NULL) return; auxtrace__free(session); auxtrace_index__free(&session->auxtrace_index); debuginfo_cache__delete(); perf_session__destroy_kernel_maps(session); perf_decomp__release_events(session->decomp_data.decomp); perf_env__exit(&session->header.env); machines__exit(&session->machines); if (session->data) { if (perf_data__is_read(session->data)) evlist__delete(session->evlist); perf_data__close(session->data); }#ifdef HAVE_LIBTRACEEVENT trace_event__cleanup(&session->tevent);#endif free(session);}
static void swap_sample_id_all(union perf_event *event, void *data){ void *end = (void *) event + event->header.size; int size;
if (data >= end) return;
size = end - data; if (size % sizeof(u64)) { pr_warning("swap_sample_id_all: unaligned sample_id_all remainder (%d), skipping swap\n", size); return; } if (size > 0) mem_bswap_64(data, size);}
static int perf_event__all64_swap(union perf_event *event, bool sample_id_all __maybe_unused){ struct perf_event_header *hdr = &event->header; size_t size = event->header.size - sizeof(*hdr);
/* mem_bswap_64 rounds up to 8-byte chunks — unaligned size overruns the buffer */ if (size % sizeof(u64)) return -1; mem_bswap_64(hdr + 1, size); return 0;}
static int perf_event__comm_swap(union perf_event *event, bool sample_id_all){ event->comm.pid = bswap_32(event->comm.pid); event->comm.tid = bswap_32(event->comm.tid);
if (sample_id_all) { void *data = &event->comm.comm; void *end = (void *)event + event->header.size; size_t len = strnlen(data, end - data);
/* * No NUL within the event boundary — can't locate where * sample_id_all starts. Reject so the event is skipped * rather than swapping garbage. */ if (len == (size_t)(end - data)) return -1; data += PERF_ALIGN(len + 1, sizeof(u64)); swap_sample_id_all(event, data); } return 0;}
static int perf_event__mmap_swap(union perf_event *event, bool sample_id_all){ event->mmap.pid = bswap_32(event->mmap.pid); event->mmap.tid = bswap_32(event->mmap.tid); event->mmap.start = bswap_64(event->mmap.start); event->mmap.len = bswap_64(event->mmap.len); event->mmap.pgoff = bswap_64(event->mmap.pgoff);
if (sample_id_all) { void *data = &event->mmap.filename; void *end = (void *)event + event->header.size; size_t len = strnlen(data, end - data);
/* See comment in perf_event__comm_swap() */ if (len == (size_t)(end - data)) return -1; data += PERF_ALIGN(len + 1, sizeof(u64)); swap_sample_id_all(event, data); } return 0;}
static int perf_event__mmap2_swap(union perf_event *event, bool sample_id_all){ event->mmap2.pid = bswap_32(event->mmap2.pid); event->mmap2.tid = bswap_32(event->mmap2.tid); event->mmap2.start = bswap_64(event->mmap2.start); event->mmap2.len = bswap_64(event->mmap2.len); event->mmap2.pgoff = bswap_64(event->mmap2.pgoff);
if (!(event->header.misc & PERF_RECORD_MISC_MMAP_BUILD_ID)) { event->mmap2.maj = bswap_32(event->mmap2.maj); event->mmap2.min = bswap_32(event->mmap2.min); event->mmap2.ino = bswap_64(event->mmap2.ino); event->mmap2.ino_generation = bswap_64(event->mmap2.ino_generation); }
if (sample_id_all) { void *data = &event->mmap2.filename; void *end = (void *)event + event->header.size; size_t len = strnlen(data, end - data);
/* See comment in perf_event__comm_swap() */ if (len == (size_t)(end - data)) return -1; data += PERF_ALIGN(len + 1, sizeof(u64)); swap_sample_id_all(event, data); } return 0;}
static int perf_event__task_swap(union perf_event *event, bool sample_id_all){ event->fork.pid = bswap_32(event->fork.pid); event->fork.tid = bswap_32(event->fork.tid); event->fork.ppid = bswap_32(event->fork.ppid); event->fork.ptid = bswap_32(event->fork.ptid); event->fork.time = bswap_64(event->fork.time);
if (sample_id_all) swap_sample_id_all(event, &event->fork + 1); return 0;}
static int perf_event__read_swap(union perf_event *event, bool sample_id_all __maybe_unused){ size_t tail;
event->read.pid = bswap_32(event->read.pid); event->read.tid = bswap_32(event->read.tid); /* * Everything after pid/tid is u64: the read values (variable * set determined by attr.read_format, which we don't have * here) optionally followed by sample_id_all fields. * Since all are u64, swap the entire remaining tail at once. */ tail = event->header.size - offsetof(struct perf_record_read, value); /* mem_bswap_64 rounds up to 8-byte chunks — unaligned tail overruns the buffer */ if (tail % sizeof(u64)) return -1; mem_bswap_64(&event->read.value, tail); return 0;}
static int perf_event__aux_swap(union perf_event *event, bool sample_id_all){ event->aux.aux_offset = bswap_64(event->aux.aux_offset); event->aux.aux_size = bswap_64(event->aux.aux_size); event->aux.flags = bswap_64(event->aux.flags);
if (sample_id_all) swap_sample_id_all(event, &event->aux + 1); return 0;}
static int perf_event__itrace_start_swap(union perf_event *event, bool sample_id_all){ event->itrace_start.pid = bswap_32(event->itrace_start.pid); event->itrace_start.tid = bswap_32(event->itrace_start.tid);
if (sample_id_all) swap_sample_id_all(event, &event->itrace_start + 1); return 0;}
static int perf_event__switch_swap(union perf_event *event, bool sample_id_all){ if (event->header.type == PERF_RECORD_SWITCH_CPU_WIDE) { event->context_switch.next_prev_pid = bswap_32(event->context_switch.next_prev_pid); event->context_switch.next_prev_tid = bswap_32(event->context_switch.next_prev_tid); }
if (sample_id_all) { /* * PERF_RECORD_SWITCH has no fields beyond the header; * SWITCH_CPU_WIDE adds pid/tid. Use the right offset * so sample_id starts at the correct position. */ if (event->header.type == PERF_RECORD_SWITCH) swap_sample_id_all(event, (void *)event + sizeof(event->header)); else swap_sample_id_all(event, &event->context_switch + 1); } return 0;}
static int perf_event__text_poke_swap(union perf_event *event, bool sample_id_all){ event->text_poke.addr = bswap_64(event->text_poke.addr); event->text_poke.old_len = bswap_16(event->text_poke.old_len); event->text_poke.new_len = bswap_16(event->text_poke.new_len);
if (sample_id_all) { void *data = &event->text_poke.old_len; void *end = (void *)event + event->header.size; size_t len = sizeof(event->text_poke.old_len) + sizeof(event->text_poke.new_len) + event->text_poke.old_len + event->text_poke.new_len;
/* old_len + new_len exceeds event — can't find sample_id_all */ if (data + len > end) return -1; data += PERF_ALIGN(len, sizeof(u64)); swap_sample_id_all(event, data); } return 0;}
static int perf_event__throttle_swap(union perf_event *event, bool sample_id_all){ event->throttle.time = bswap_64(event->throttle.time); event->throttle.id = bswap_64(event->throttle.id); event->throttle.stream_id = bswap_64(event->throttle.stream_id);
if (sample_id_all) swap_sample_id_all(event, &event->throttle + 1); return 0;}
static int perf_event__namespaces_swap(union perf_event *event, bool sample_id_all){ u64 i, nr, max_nr;
event->namespaces.pid = bswap_32(event->namespaces.pid); event->namespaces.tid = bswap_32(event->namespaces.tid); event->namespaces.nr_namespaces = bswap_64(event->namespaces.nr_namespaces);
nr = event->namespaces.nr_namespaces; /* * Cannot underflow: perf_event__min_size[] guarantees header.size >= sizeof. * When sample_id_all is present max_nr slightly overestimates the * array space because header.size includes the trailing sample_id. * Harmless: both the per-element bswap_64 loop and swap_sample_id_all() * perform the same u64 byte swap, so the result is correct regardless * of where the boundary between array and sample_id falls. */ max_nr = (event->header.size - sizeof(event->namespaces)) / sizeof(event->namespaces.link_info[0]); /* * Safe to clamp: each namespace entry is indexed by type; * missing entries just won't be resolved. */ if (nr > max_nr) { pr_warning("WARNING: PERF_RECORD_NAMESPACES: nr_namespaces %" PRIu64 " exceeds payload (max %" PRIu64 "), clamping\n", nr, max_nr); nr = max_nr; event->namespaces.nr_namespaces = nr; }
for (i = 0; i < nr; i++) { struct perf_ns_link_info *ns = &event->namespaces.link_info[i];
ns->dev = bswap_64(ns->dev); ns->ino = bswap_64(ns->ino); }
if (sample_id_all) swap_sample_id_all(event, &event->namespaces.link_info[i]); return 0;}
static int perf_event__cgroup_swap(union perf_event *event, bool sample_id_all){ event->cgroup.id = bswap_64(event->cgroup.id);
if (sample_id_all) { void *data = &event->cgroup.path; void *end = (void *)event + event->header.size; size_t len = strnlen(data, end - data);
/* See comment in perf_event__comm_swap() */ if (len == (size_t)(end - data)) return -1; data += PERF_ALIGN(len + 1, sizeof(u64)); swap_sample_id_all(event, data); } return 0;}
static u8 revbyte(u8 b){ int rev = (b >> 4) | ((b & 0xf) << 4); rev = ((rev & 0xcc) >> 2) | ((rev & 0x33) << 2); rev = ((rev & 0xaa) >> 1) | ((rev & 0x55) << 1); return (u8) rev;}
/* * XXX this is hack in attempt to carry flags bitfield * through endian village. ABI says: * * Bit-fields are allocated from right to left (least to most significant) * on little-endian implementations and from left to right (most to least * significant) on big-endian implementations. * * The above seems to be byte specific, so we need to reverse each * byte of the bitfield. 'Internet' also says this might be implementation * specific and we probably need proper fix and carry perf_event_attr * bitfield flags in separate data file FEAT_ section. Thought this seems * to work for now. */static void swap_bitfield(u8 *p, unsigned len){ unsigned i;
for (i = 0; i < len; i++) { *p = revbyte(*p); p++; }}
/* exported for swapping attributes in file header */void perf_event__attr_swap(struct perf_event_attr *attr){ attr->type = bswap_32(attr->type); attr->size = bswap_32(attr->size);
/* * ABI0: size == 0 means the producer didn't set it. * Assume PERF_ATTR_SIZE_VER0 so bswap_safe() below * correctly swaps the VER0 fields instead of skipping * everything. Same convention as read_attr(). */ if (!attr->size) attr->size = PERF_ATTR_SIZE_VER0;
/* Verify the full field extent fits, not just its start offset */#define bswap_safe(f, n) \ (attr->size >= (offsetof(struct perf_event_attr, f) + \ sizeof(attr->f) * ((n) + 1)))#define bswap_field(f, sz) \do { \ if (bswap_safe(f, 0)) \ attr->f = bswap_##sz(attr->f); \} while(0)#define bswap_field_16(f) bswap_field(f, 16)#define bswap_field_32(f) bswap_field(f, 32)#define bswap_field_64(f) bswap_field(f, 64)
bswap_field_64(config); bswap_field_64(sample_period); bswap_field_64(sample_type); bswap_field_64(read_format); bswap_field_32(wakeup_events); bswap_field_32(bp_type); bswap_field_64(bp_addr); bswap_field_64(bp_len); bswap_field_64(branch_sample_type); bswap_field_64(sample_regs_user); bswap_field_32(sample_stack_user); bswap_field_32(aux_watermark); bswap_field_16(sample_max_stack); bswap_field_32(aux_sample_size);
/* * After read_format are bitfields. Check read_format because * we are unable to use offsetof on bitfield. */ if (bswap_safe(read_format, 1)) swap_bitfield((u8 *) (&attr->read_format + 1), sizeof(u64));#undef bswap_field_64#undef bswap_field_32#undef bswap_field#undef bswap_safe}
static int perf_event__hdr_attr_swap(union perf_event *event, bool sample_id_all __maybe_unused){ u32 attr_size, payload_size; size_t size;
/* * Validate attr.size (still foreign-endian) before calling * perf_event__attr_swap(), which uses it via bswap_safe() * to decide which fields to swap. A crafted attr.size * larger than the event payload would swap past the event * boundary and corrupt adjacent memory. * * header.size alignment is already validated by * perf_session__process_event(). The min_size table * guarantees header.size >= sizeof(header) + * PERF_ATTR_SIZE_VER0, so attr.size is safe to access. */ attr_size = bswap_32(event->attr.attr.size); /* * ABI0: size field not set. This only happens in pipe/inject * mode where HEADER_ATTR events carry their own attr. For * regular perf.data files, read_attr() uses f_header.attr_size * from the file header instead. Assume PERF_ATTR_SIZE_VER0. */ if (!attr_size) attr_size = PERF_ATTR_SIZE_VER0; payload_size = event->header.size - sizeof(event->header);
if (attr_size < PERF_ATTR_SIZE_VER0 || attr_size % sizeof(u64) || attr_size > payload_size) { pr_err("PERF_RECORD_HEADER_ATTR: invalid attr.size %u (min: %d, max: %u, 8-byte aligned)\n", attr_size, PERF_ATTR_SIZE_VER0, payload_size); return -1; }
perf_event__attr_swap(&event->attr.attr);
size = event->header.size; size -= perf_record_header_attr_id(event) - (void *)event; mem_bswap_64(perf_record_header_attr_id(event), size); return 0;}
static int perf_event__build_id_swap(union perf_event *event, bool sample_id_all){ event->build_id.pid = bswap_32(event->build_id.pid);
if (sample_id_all) { void *data = &event->build_id.filename; void *end = (void *)event + event->header.size; size_t len = strnlen(data, end - data);
/* See comment in perf_event__comm_swap() */ if (len == (size_t)(end - data)) return -1; data += PERF_ALIGN(len + 1, sizeof(u64)); swap_sample_id_all(event, data); } return 0;}
static int perf_event__event_update_swap(union perf_event *event, bool sample_id_all __maybe_unused){ struct perf_record_event_update *ev = &event->event_update;
ev->type = bswap_64(ev->type); ev->id = bswap_64(ev->id);
/* * Swap variant-specific fields so the processing path * sees native byte order. */ if (ev->type == PERF_EVENT_UPDATE__SCALE) { if (event->header.size < offsetof(struct perf_record_event_update, scale) + sizeof(ev->scale)) return -1; mem_bswap_64(&ev->scale.scale, sizeof(ev->scale.scale)); } else if (ev->type == PERF_EVENT_UPDATE__CPUS) { u32 cpus_payload; struct perf_record_cpu_map_data *data = &ev->cpus.cpus;
/* CPUS fields start at the same offset as scale (union) */ if (event->header.size < offsetof(struct perf_record_event_update, cpus) + sizeof(__u16) + sizeof(struct perf_record_range_cpu_map)) return -1; cpus_payload = event->header.size - offsetof(struct perf_record_event_update, cpus); data->type = bswap_16(data->type); /* * Full swap including array elements — same logic as * perf_event__cpu_map_swap() but scoped to the * embedded cpu_map_data within EVENT_UPDATE. */ switch (data->type) { case PERF_CPU_MAP__CPUS: { u16 nr, max_nr;
data->cpus_data.nr = bswap_16(data->cpus_data.nr); nr = data->cpus_data.nr; max_nr = (cpus_payload - offsetof(struct perf_record_cpu_map_data, cpus_data.cpu)) / sizeof(data->cpus_data.cpu[0]); if (nr > max_nr) { nr = max_nr; data->cpus_data.nr = nr; } for (unsigned int i = 0; i < nr; i++) data->cpus_data.cpu[i] = bswap_16(data->cpus_data.cpu[i]); break; } case PERF_CPU_MAP__MASK: data->mask32_data.long_size = bswap_16(data->mask32_data.long_size); switch (data->mask32_data.long_size) { case 4: { u16 nr, max_nr;
data->mask32_data.nr = bswap_16(data->mask32_data.nr); nr = data->mask32_data.nr; max_nr = (cpus_payload - offsetof(struct perf_record_cpu_map_data, mask32_data.mask)) / sizeof(data->mask32_data.mask[0]); if (nr > max_nr) { nr = max_nr; data->mask32_data.nr = nr; } for (unsigned int i = 0; i < nr; i++) data->mask32_data.mask[i] = bswap_32(data->mask32_data.mask[i]); break; } case 8: { u16 nr, max_nr;
data->mask64_data.nr = bswap_16(data->mask64_data.nr); nr = data->mask64_data.nr; if (cpus_payload < offsetof(struct perf_record_cpu_map_data, mask64_data.mask)) { data->mask64_data.nr = 0; break; } max_nr = (cpus_payload - offsetof(struct perf_record_cpu_map_data, mask64_data.mask)) / sizeof(data->mask64_data.mask[0]); if (nr > max_nr) { nr = max_nr; data->mask64_data.nr = nr; } for (unsigned int i = 0; i < nr; i++) data->mask64_data.mask[i] = bswap_64(data->mask64_data.mask[i]); break; } default: break; } break; case PERF_CPU_MAP__RANGE_CPUS: data->range_cpu_data.start_cpu = bswap_16(data->range_cpu_data.start_cpu); data->range_cpu_data.end_cpu = bswap_16(data->range_cpu_data.end_cpu); break; default: break; } } return 0;}
static int perf_event__event_type_swap(union perf_event *event, bool sample_id_all __maybe_unused){ event->event_type.event_type.event_id = bswap_64(event->event_type.event_type.event_id); return 0;}
static int perf_event__tracing_data_swap(union perf_event *event, bool sample_id_all __maybe_unused){ event->tracing_data.size = bswap_32(event->tracing_data.size); return 0;}
static int perf_event__auxtrace_info_swap(union perf_event *event, bool sample_id_all __maybe_unused){ size_t size;
event->auxtrace_info.type = bswap_32(event->auxtrace_info.type);
size = event->header.size; size -= (void *)&event->auxtrace_info.priv - (void *)event; mem_bswap_64(event->auxtrace_info.priv, size); return 0;}
static int perf_event__auxtrace_swap(union perf_event *event, bool sample_id_all __maybe_unused){ event->auxtrace.size = bswap_64(event->auxtrace.size); event->auxtrace.offset = bswap_64(event->auxtrace.offset); event->auxtrace.reference = bswap_64(event->auxtrace.reference); event->auxtrace.idx = bswap_32(event->auxtrace.idx); event->auxtrace.tid = bswap_32(event->auxtrace.tid); event->auxtrace.cpu = bswap_32(event->auxtrace.cpu); return 0;}
static int perf_event__auxtrace_error_swap(union perf_event *event, bool sample_id_all __maybe_unused){ event->auxtrace_error.type = bswap_32(event->auxtrace_error.type); event->auxtrace_error.code = bswap_32(event->auxtrace_error.code); event->auxtrace_error.cpu = bswap_32(event->auxtrace_error.cpu); event->auxtrace_error.pid = bswap_32(event->auxtrace_error.pid); event->auxtrace_error.tid = bswap_32(event->auxtrace_error.tid); event->auxtrace_error.fmt = bswap_32(event->auxtrace_error.fmt); event->auxtrace_error.ip = bswap_64(event->auxtrace_error.ip); if (event->auxtrace_error.fmt) event->auxtrace_error.time = bswap_64(event->auxtrace_error.time); if (event->auxtrace_error.fmt >= 2) { /* * fmt >= 2 adds machine_pid and vcpu after msg[64]. * Older files may have fmt >= 2 but an event size * that doesn't include these fields — downgrade to * avoid swapping out of bounds. */ if (event->header.size < offsetof(typeof(event->auxtrace_error), vcpu) + sizeof(event->auxtrace_error.vcpu)) { pr_warning("WARNING: PERF_RECORD_AUXTRACE_ERROR: fmt %u but event too small for machine_pid/vcpu (%u bytes), downgrading fmt\n", event->auxtrace_error.fmt, event->header.size); event->auxtrace_error.fmt = 1; } else { event->auxtrace_error.machine_pid = bswap_32(event->auxtrace_error.machine_pid); event->auxtrace_error.vcpu = bswap_32(event->auxtrace_error.vcpu); } } return 0;}
static int perf_event__thread_map_swap(union perf_event *event, bool sample_id_all __maybe_unused){ unsigned int i; u64 nr;
event->thread_map.nr = bswap_64(event->thread_map.nr);
/* * Reject rather than clamp: unlike namespaces (indexed by type) * or stat_config (self-describing tags), a truncated thread map * is structurally broken — downstream would get a wrong map. */ /* Cannot underflow: perf_event__min_size[] guarantees header.size >= sizeof */ nr = event->thread_map.nr; if (nr > (event->header.size - sizeof(event->thread_map)) / sizeof(event->thread_map.entries[0])) return -1;
for (i = 0; i < nr; i++) event->thread_map.entries[i].pid = bswap_64(event->thread_map.entries[i].pid); return 0;}
static int perf_event__cpu_map_swap(union perf_event *event, bool sample_id_all __maybe_unused){ struct perf_record_cpu_map_data *data = &event->cpu_map.data; u32 payload = event->header.size - sizeof(event->header);
data->type = bswap_16(data->type);
/* * Safe to clamp: a shorter CPU map just means some CPUs * are absent; tools process the CPUs that are present. */ switch (data->type) { case PERF_CPU_MAP__CPUS: { u16 nr, max_nr;
data->cpus_data.nr = bswap_16(data->cpus_data.nr); nr = data->cpus_data.nr; max_nr = (payload - offsetof(struct perf_record_cpu_map_data, cpus_data.cpu)) / sizeof(data->cpus_data.cpu[0]); if (nr > max_nr) { pr_warning("WARNING: PERF_RECORD_CPU_MAP: nr %u exceeds payload (max %u), clamping\n", nr, max_nr); nr = max_nr; data->cpus_data.nr = nr; } for (unsigned int i = 0; i < nr; i++) data->cpus_data.cpu[i] = bswap_16(data->cpus_data.cpu[i]); break; } case PERF_CPU_MAP__MASK: data->mask32_data.long_size = bswap_16(data->mask32_data.long_size);
switch (data->mask32_data.long_size) { case 4: { u16 nr, max_nr;
data->mask32_data.nr = bswap_16(data->mask32_data.nr); nr = data->mask32_data.nr; max_nr = (payload - offsetof(struct perf_record_cpu_map_data, mask32_data.mask)) / sizeof(data->mask32_data.mask[0]); if (nr > max_nr) { pr_warning("WARNING: PERF_RECORD_CPU_MAP mask32: nr %u exceeds payload (max %u), clamping\n", nr, max_nr); nr = max_nr; data->mask32_data.nr = nr; } for (unsigned int i = 0; i < nr; i++) data->mask32_data.mask[i] = bswap_32(data->mask32_data.mask[i]); break; } case 8: { u16 nr, max_nr;
data->mask64_data.nr = bswap_16(data->mask64_data.nr); nr = data->mask64_data.nr; if (payload < offsetof(struct perf_record_cpu_map_data, mask64_data.mask)) { data->mask64_data.nr = 0; break; } max_nr = (payload - offsetof(struct perf_record_cpu_map_data, mask64_data.mask)) / sizeof(data->mask64_data.mask[0]); if (nr > max_nr) { pr_warning("WARNING: PERF_RECORD_CPU_MAP mask64: nr %u exceeds payload (max %u), clamping\n", nr, max_nr); nr = max_nr; data->mask64_data.nr = nr; } for (unsigned int i = 0; i < nr; i++) data->mask64_data.mask[i] = bswap_64(data->mask64_data.mask[i]); break; } default: pr_err("cpu_map swap: unsupported long size %u\n", data->mask32_data.long_size); } break; case PERF_CPU_MAP__RANGE_CPUS: data->range_cpu_data.start_cpu = bswap_16(data->range_cpu_data.start_cpu); data->range_cpu_data.end_cpu = bswap_16(data->range_cpu_data.end_cpu); break; default: break; } return 0;}
static int perf_event__stat_config_swap(union perf_event *event, bool sample_id_all __maybe_unused){ u64 nr, max_nr, size;
nr = bswap_64(event->stat_config.nr); /* Cannot underflow: perf_event__min_size[] guarantees header.size >= sizeof */ max_nr = (event->header.size - sizeof(event->stat_config)) / sizeof(event->stat_config.data[0]); /* * Safe to clamp: each config entry is self-describing * via its tag; missing entries keep their defaults. */ if (nr > max_nr) { pr_warning("WARNING: PERF_RECORD_STAT_CONFIG: nr %" PRIu64 " exceeds payload (max %" PRIu64 "), clamping\n", nr, max_nr); nr = max_nr; } size = nr * sizeof(event->stat_config.data[0]); /* The swap starts at &nr, so add its size to cover the full range */ size += sizeof(event->stat_config.nr); mem_bswap_64(&event->stat_config.nr, size); /* Persist the clamped value in native byte order */ event->stat_config.nr = nr; return 0;}
static int perf_event__stat_swap(union perf_event *event, bool sample_id_all __maybe_unused){ event->stat.id = bswap_64(event->stat.id); event->stat.thread = bswap_32(event->stat.thread); event->stat.cpu = bswap_32(event->stat.cpu); event->stat.val = bswap_64(event->stat.val); event->stat.ena = bswap_64(event->stat.ena); event->stat.run = bswap_64(event->stat.run); return 0;}
static int perf_event__stat_round_swap(union perf_event *event, bool sample_id_all __maybe_unused){ event->stat_round.type = bswap_64(event->stat_round.type); event->stat_round.time = bswap_64(event->stat_round.time); return 0;}
static int perf_event__time_conv_swap(union perf_event *event, bool sample_id_all __maybe_unused){ event->time_conv.time_shift = bswap_64(event->time_conv.time_shift); event->time_conv.time_mult = bswap_64(event->time_conv.time_mult); event->time_conv.time_zero = bswap_64(event->time_conv.time_zero);
if (event_contains(event->time_conv, time_cycles)) event->time_conv.time_cycles = bswap_64(event->time_conv.time_cycles); if (event_contains(event->time_conv, time_mask)) event->time_conv.time_mask = bswap_64(event->time_conv.time_mask); return 0;}
static int perf_event__compressed2_swap(union perf_event *event, bool sample_id_all __maybe_unused){ /* Only data_size needs swapping — compressed payload is a raw byte stream */ event->pack2.data_size = bswap_64(event->pack2.data_size); return 0;}
static int perf_event__bpf_metadata_swap(union perf_event *event, bool sample_id_all __maybe_unused){ u64 i, nr, max_nr;
/* Fixed header must fit before accessing nr_entries or prog_name */ if (event->header.size < sizeof(event->bpf_metadata)) return -1;
event->bpf_metadata.nr_entries = bswap_64(event->bpf_metadata.nr_entries);
/* * Ensure NUL-termination on the cross-endian path where the * mapping is writable (MAP_PRIVATE + PROT_WRITE). Fixing * the string in place is preferred over rejecting because it * preserves the event for downstream processing — only the * last byte is lost. * * The native-endian path (MAP_SHARED + PROT_READ) cannot * write, so it validates and skips unterminated events in * perf_session__process_user_event() instead. The two * strategies produce different outcomes for the same * malformed input (fix vs skip), which is inherent in the * writable-vs-read-only mapping model. */ event->bpf_metadata.prog_name[BPF_PROG_NAME_LEN - 1] = '\0';
nr = event->bpf_metadata.nr_entries; max_nr = (event->header.size - sizeof(event->bpf_metadata)) / sizeof(event->bpf_metadata.entries[0]); if (nr > max_nr) { /* Persist clamped value so the native path processes entries, not skips */ nr = max_nr; event->bpf_metadata.nr_entries = nr; }
for (i = 0; i < nr; i++) { event->bpf_metadata.entries[i].key[BPF_METADATA_KEY_LEN - 1] = '\0'; event->bpf_metadata.entries[i].value[BPF_METADATA_VALUE_LEN - 1] = '\0'; } return 0;}static intperf_event__schedstat_cpu_swap(union perf_event *event __maybe_unused, bool sample_id_all __maybe_unused){ /* FIXME */ return 0;}
static intperf_event__schedstat_domain_swap(union perf_event *event __maybe_unused, bool sample_id_all __maybe_unused){ /* FIXME */ return 0;}
static int perf_event__ksymbol_swap(union perf_event *event, bool sample_id_all){ event->ksymbol.addr = bswap_64(event->ksymbol.addr); event->ksymbol.len = bswap_32(event->ksymbol.len); event->ksymbol.ksym_type = bswap_16(event->ksymbol.ksym_type); event->ksymbol.flags = bswap_16(event->ksymbol.flags);
if (sample_id_all) { void *data = &event->ksymbol.name; void *end = (void *)event + event->header.size; size_t len = strnlen(data, end - data);
/* See comment in perf_event__comm_swap() */ if (len == (size_t)(end - data)) return -1; data += PERF_ALIGN(len + 1, sizeof(u64)); swap_sample_id_all(event, data); } return 0;}
static int perf_event__bpf_event_swap(union perf_event *event, bool sample_id_all){ event->bpf.type = bswap_16(event->bpf.type); event->bpf.flags = bswap_16(event->bpf.flags); event->bpf.id = bswap_32(event->bpf.id);
if (sample_id_all) swap_sample_id_all(event, &event->bpf + 1); return 0;}
static int perf_event__header_feature_swap(union perf_event *event, bool sample_id_all __maybe_unused){ event->feat.feat_id = bswap_64(event->feat.feat_id); return 0;}
typedef int (*perf_event__swap_op)(union perf_event *event, bool sample_id_all);
static perf_event__swap_op perf_event__swap_ops[] = { [PERF_RECORD_MMAP] = perf_event__mmap_swap, [PERF_RECORD_MMAP2] = perf_event__mmap2_swap, [PERF_RECORD_COMM] = perf_event__comm_swap, [PERF_RECORD_FORK] = perf_event__task_swap, [PERF_RECORD_EXIT] = perf_event__task_swap, [PERF_RECORD_LOST] = perf_event__all64_swap, [PERF_RECORD_READ] = perf_event__read_swap, [PERF_RECORD_THROTTLE] = perf_event__throttle_swap, [PERF_RECORD_UNTHROTTLE] = perf_event__throttle_swap, [PERF_RECORD_SAMPLE] = perf_event__all64_swap, [PERF_RECORD_AUX] = perf_event__aux_swap, [PERF_RECORD_ITRACE_START] = perf_event__itrace_start_swap, [PERF_RECORD_LOST_SAMPLES] = perf_event__all64_swap, [PERF_RECORD_SWITCH] = perf_event__switch_swap, [PERF_RECORD_SWITCH_CPU_WIDE] = perf_event__switch_swap, [PERF_RECORD_NAMESPACES] = perf_event__namespaces_swap, [PERF_RECORD_CGROUP] = perf_event__cgroup_swap, [PERF_RECORD_KSYMBOL] = perf_event__ksymbol_swap, [PERF_RECORD_BPF_EVENT] = perf_event__bpf_event_swap, [PERF_RECORD_TEXT_POKE] = perf_event__text_poke_swap, [PERF_RECORD_AUX_OUTPUT_HW_ID] = perf_event__all64_swap, [PERF_RECORD_CALLCHAIN_DEFERRED] = perf_event__all64_swap, [PERF_RECORD_HEADER_ATTR] = perf_event__hdr_attr_swap, [PERF_RECORD_HEADER_EVENT_TYPE] = perf_event__event_type_swap, [PERF_RECORD_HEADER_TRACING_DATA] = perf_event__tracing_data_swap, [PERF_RECORD_HEADER_BUILD_ID] = perf_event__build_id_swap, [PERF_RECORD_HEADER_FEATURE] = perf_event__header_feature_swap, [PERF_RECORD_ID_INDEX] = perf_event__all64_swap, [PERF_RECORD_AUXTRACE_INFO] = perf_event__auxtrace_info_swap, [PERF_RECORD_AUXTRACE] = perf_event__auxtrace_swap, [PERF_RECORD_AUXTRACE_ERROR] = perf_event__auxtrace_error_swap, [PERF_RECORD_THREAD_MAP] = perf_event__thread_map_swap, [PERF_RECORD_CPU_MAP] = perf_event__cpu_map_swap, [PERF_RECORD_STAT_CONFIG] = perf_event__stat_config_swap, [PERF_RECORD_STAT] = perf_event__stat_swap, [PERF_RECORD_STAT_ROUND] = perf_event__stat_round_swap, [PERF_RECORD_EVENT_UPDATE] = perf_event__event_update_swap, [PERF_RECORD_TIME_CONV] = perf_event__time_conv_swap, [PERF_RECORD_COMPRESSED2] = perf_event__compressed2_swap, [PERF_RECORD_BPF_METADATA] = perf_event__bpf_metadata_swap, [PERF_RECORD_SCHEDSTAT_CPU] = perf_event__schedstat_cpu_swap, [PERF_RECORD_SCHEDSTAT_DOMAIN] = perf_event__schedstat_domain_swap, [PERF_RECORD_HEADER_MAX] = NULL,};
/* * When perf record finishes a pass on every buffers, it records this pseudo * event. * We record the max timestamp t found in the pass n. * Assuming these timestamps are monotonic across cpus, we know that if * a buffer still has events with timestamps below t, they will be all * available and then read in the pass n + 1. * Hence when we start to read the pass n + 2, we can safely flush every * events with timestamps below t. * * ============ PASS n ================= * CPU 0 | CPU 1 * | * cnt1 timestamps | cnt2 timestamps * 1 | 2 * 2 | 3 * - | 4 <--- max recorded * * ============ PASS n + 1 ============== * CPU 0 | CPU 1 * | * cnt1 timestamps | cnt2 timestamps * 3 | 5 * 4 | 6 * 5 | 7 <---- max recorded * * Flush every events below timestamp 4 * * ============ PASS n + 2 ============== * CPU 0 | CPU 1 * | * cnt1 timestamps | cnt2 timestamps * 6 | 8 * 7 | 9 * - | 10 * * Flush every events below timestamp 7 * etc... */int perf_event__process_finished_round(const struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct ordered_events *oe){ if (dump_trace) fprintf(stdout, "\n"); return ordered_events__flush(oe, OE_FLUSH__ROUND);}
int perf_session__queue_event(struct perf_session *s, union perf_event *event, u64 timestamp, u64 file_offset, const char *file_path){ return ordered_events__queue(&s->ordered_events, event, timestamp, file_offset, file_path);}
static void callchain__lbr_callstack_printf(struct perf_sample *sample){ struct ip_callchain *callchain = sample->callchain; struct branch_stack *lbr_stack = sample->branch_stack; struct branch_entry *entries = perf_sample__branch_entries(sample); u64 kernel_callchain_nr = callchain->nr; unsigned int i;
for (i = 0; i < kernel_callchain_nr; i++) { if (callchain->ips[i] == PERF_CONTEXT_USER) break; }
if ((i != kernel_callchain_nr) && lbr_stack->nr) { u64 total_nr; /* * LBR callstack can only get user call chain, * i is kernel call chain number, * 1 is PERF_CONTEXT_USER. * * The user call chain is stored in LBR registers. * LBR are pair registers. The caller is stored * in "from" register, while the callee is stored * in "to" register. * For example, there is a call stack * "A"->"B"->"C"->"D". * The LBR registers will be recorded like * "C"->"D", "B"->"C", "A"->"B". * So only the first "to" register and all "from" * registers are needed to construct the whole stack. */ total_nr = i + 1 + lbr_stack->nr + 1; kernel_callchain_nr = i + 1;
printf("... LBR call chain: nr:%" PRIu64 "\n", total_nr);
for (i = 0; i < kernel_callchain_nr; i++) printf("..... %2d: %016" PRIx64 "\n", i, callchain->ips[i]);
printf("..... %2d: %016" PRIx64 "\n", (int)(kernel_callchain_nr), entries[0].to); for (i = 0; i < lbr_stack->nr; i++) printf("..... %2d: %016" PRIx64 "\n", (int)(i + kernel_callchain_nr + 1), entries[i].from); }}
static const char *callchain_context_str(u64 ip){ switch (ip) { case PERF_CONTEXT_HV: return " (PERF_CONTEXT_HV)"; case PERF_CONTEXT_KERNEL: return " (PERF_CONTEXT_KERNEL)"; case PERF_CONTEXT_USER: return " (PERF_CONTEXT_USER)"; case PERF_CONTEXT_GUEST: return " (PERF_CONTEXT_GUEST)"; case PERF_CONTEXT_GUEST_KERNEL: return " (PERF_CONTEXT_GUEST_KERNEL)"; case PERF_CONTEXT_GUEST_USER: return " (PERF_CONTEXT_GUEST_USER)"; case PERF_CONTEXT_USER_DEFERRED: return " (PERF_CONTEXT_USER_DEFERRED)"; default: return ""; }}
static void callchain__printf(struct evsel *evsel, struct perf_sample *sample){ unsigned int i; struct ip_callchain *callchain = sample->callchain;
if (evsel__has_branch_callstack(evsel)) callchain__lbr_callstack_printf(sample);
printf("... FP chain: nr:%" PRIu64 "\n", callchain->nr);
for (i = 0; i < callchain->nr; i++) printf("..... %2d: %016" PRIx64 "%s\n", i, callchain->ips[i], callchain_context_str(callchain->ips[i]));
if (sample->deferred_callchain) printf("...... (deferred)\n");}
static void branch_stack__printf(struct perf_sample *sample, struct evsel *evsel){ struct branch_entry *entries = perf_sample__branch_entries(sample); bool callstack = evsel__has_branch_callstack(evsel); u64 *branch_stack_cntr = sample->branch_stack_cntr; uint64_t i;
if (!callstack) { printf("%s: nr:%" PRIu64 "\n", "... branch stack", sample->branch_stack->nr); } else { /* the reason of adding 1 to nr is because after expanding * branch stack it generates nr + 1 callstack records. e.g., * B()->C() * A()->B() * the final callstack should be: * C() * B() * A() */ printf("%s: nr:%" PRIu64 "\n", "... branch callstack", sample->branch_stack->nr+1); }
for (i = 0; i < sample->branch_stack->nr; i++) { struct branch_entry *e = &entries[i];
if (!callstack) { printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 " %hu cycles %s%s%s%s %x %s %s\n", i, e->from, e->to, (unsigned short)e->flags.cycles, e->flags.mispred ? "M" : " ", e->flags.predicted ? "P" : " ", e->flags.abort ? "A" : " ", e->flags.in_tx ? "T" : " ", (unsigned)e->flags.reserved, get_branch_type(e), e->flags.spec ? branch_spec_desc(e->flags.spec) : ""); } else { if (i == 0) { printf("..... %2"PRIu64": %016" PRIx64 "\n" "..... %2"PRIu64": %016" PRIx64 "\n", i, e->to, i+1, e->from); } else { printf("..... %2"PRIu64": %016" PRIx64 "\n", i+1, e->from); } } }
if (branch_stack_cntr) { unsigned int br_cntr_width, br_cntr_nr;
perf_env__find_br_cntr_info(evsel__env(evsel), &br_cntr_nr, &br_cntr_width); printf("... branch stack counters: nr:%" PRIu64 " (counter width: %u max counter nr:%u)\n", sample->branch_stack->nr, br_cntr_width, br_cntr_nr); for (i = 0; i < sample->branch_stack->nr; i++) printf("..... %2"PRIu64": %016" PRIx64 "\n", i, branch_stack_cntr[i]); }}
static void regs_dump__printf(u64 mask, u64 *regs, uint16_t e_machine, uint32_t e_flags){ unsigned rid, i = 0;
for_each_set_bit(rid, (unsigned long *) &mask, sizeof(mask) * 8) { u64 val = regs[i++];
printf(".... %-5s 0x%016" PRIx64 "\n", perf_reg_name(rid, e_machine, e_flags), val); }}
static const char *regs_abi[] = { [PERF_SAMPLE_REGS_ABI_NONE] = "none", [PERF_SAMPLE_REGS_ABI_32] = "32-bit", [PERF_SAMPLE_REGS_ABI_64] = "64-bit",};
static inline const char *regs_dump_abi(struct regs_dump *d){ if (d->abi > PERF_SAMPLE_REGS_ABI_64) return "unknown";
return regs_abi[d->abi];}
static void regs__printf(const char *type, struct regs_dump *regs, uint16_t e_machine, uint32_t e_flags){ u64 mask = regs->mask;
printf("... %s regs: mask 0x%" PRIx64 " ABI %s\n", type, mask, regs_dump_abi(regs));
regs_dump__printf(mask, regs->regs, e_machine, e_flags);}
static void regs_user__printf(struct perf_sample *sample, uint16_t e_machine, uint32_t e_flags){ struct regs_dump *user_regs;
if (!sample->user_regs) return;
user_regs = perf_sample__user_regs(sample);
if (user_regs->regs) regs__printf("user", user_regs, e_machine, e_flags);}
static void regs_intr__printf(struct perf_sample *sample, uint16_t e_machine, uint32_t e_flags){ struct regs_dump *intr_regs;
if (!sample->intr_regs) return;
intr_regs = perf_sample__intr_regs(sample);
if (intr_regs->regs) regs__printf("intr", intr_regs, e_machine, e_flags);}
static void stack_user__printf(struct stack_dump *dump){ printf("... ustack: size %" PRIu64 ", offset 0x%x\n", dump->size, dump->offset);}
static void evlist__print_tstamp(struct evlist *evlist, union perf_event *event, struct perf_sample *sample){ u64 sample_type = __evlist__combined_sample_type(evlist);
if (event->header.type != PERF_RECORD_SAMPLE && !evlist__sample_id_all(evlist)) { fputs("-1 -1 ", stdout); return; }
if ((sample_type & PERF_SAMPLE_CPU)) printf("%u ", sample->cpu);
if (sample_type & PERF_SAMPLE_TIME) printf("%" PRIu64 " ", sample->time);}
static void sample_read__printf(struct perf_sample *sample, u64 read_format){ printf("... sample_read:\n");
if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) printf("...... time enabled %016" PRIx64 "\n", sample->read.time_enabled);
if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) printf("...... time running %016" PRIx64 "\n", sample->read.time_running);
if (read_format & PERF_FORMAT_GROUP) { struct sample_read_value *value = sample->read.group.values;
printf(".... group nr %" PRIu64 "\n", sample->read.group.nr);
sample_read_group__for_each(value, sample->read.group.nr, read_format) { printf("..... id %016" PRIx64 ", value %016" PRIx64, value->id, value->value); if (read_format & PERF_FORMAT_LOST) printf(", lost %" PRIu64, value->lost); printf("\n"); } } else { printf("..... id %016" PRIx64 ", value %016" PRIx64, sample->read.one.id, sample->read.one.value); if (read_format & PERF_FORMAT_LOST) printf(", lost %" PRIu64, sample->read.one.lost); printf("\n"); }}
static void dump_event(struct evlist *evlist, union perf_event *event, u64 file_offset, struct perf_sample *sample, const char *file_path){ if (!dump_trace) return;
printf("\n%#" PRIx64 "@%s [%#x]: event: %d\n", file_offset, file_path, event->header.size, event->header.type);
trace_event(event); if (event->header.type == PERF_RECORD_SAMPLE && evlist->trace_event_sample_raw) evlist->trace_event_sample_raw(evlist, event, sample);
if (sample) evlist__print_tstamp(evlist, event, sample);
printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset, event->header.size, perf_event__name(event->header.type));}
char *get_page_size_name(u64 size, char *str){ if (!size || !unit_number__scnprintf(str, PAGE_SIZE_NAME_LEN, size)) snprintf(str, PAGE_SIZE_NAME_LEN, "%s", "N/A");
return str;}
static void dump_sample(struct machine *machine, union perf_event *event, struct perf_sample *sample){ struct evsel *evsel = sample->evsel; u64 sample_type; char str[PAGE_SIZE_NAME_LEN]; uint16_t e_machine = EM_NONE; uint32_t e_flags = 0;
if (!dump_trace) return;
sample_type = evsel->core.attr.sample_type;
if (sample_type & (PERF_SAMPLE_REGS_USER | PERF_SAMPLE_REGS_INTR)) { struct thread *thread = machine__find_thread(machine, sample->pid, sample->pid);
e_machine = thread__e_machine(thread, machine, &e_flags); }
printf("(IP, 0x%x): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n", event->header.misc, sample->pid, sample->tid, sample->ip, sample->period, sample->addr);
if (evsel__has_callchain(evsel)) callchain__printf(evsel, sample);
if (evsel__has_br_stack(evsel)) branch_stack__printf(sample, evsel);
if (sample_type & PERF_SAMPLE_REGS_USER) regs_user__printf(sample, e_machine, e_flags);
if (sample_type & PERF_SAMPLE_REGS_INTR) regs_intr__printf(sample, e_machine, e_flags);
if (sample_type & PERF_SAMPLE_STACK_USER) stack_user__printf(&sample->user_stack);
if (sample_type & PERF_SAMPLE_WEIGHT_TYPE) { printf("... weight: %" PRIu64 "", sample->weight); if (sample_type & PERF_SAMPLE_WEIGHT_STRUCT) { printf(",0x%"PRIx16"", sample->ins_lat); printf(",0x%"PRIx16"", sample->weight3); } printf("\n"); }
if (sample_type & PERF_SAMPLE_DATA_SRC) printf(" . data_src: 0x%"PRIx64"\n", sample->data_src);
if (sample_type & PERF_SAMPLE_PHYS_ADDR) printf(" .. phys_addr: 0x%"PRIx64"\n", sample->phys_addr);
if (sample_type & PERF_SAMPLE_DATA_PAGE_SIZE) printf(" .. data page size: %s\n", get_page_size_name(sample->data_page_size, str));
if (sample_type & PERF_SAMPLE_CODE_PAGE_SIZE) printf(" .. code page size: %s\n", get_page_size_name(sample->code_page_size, str));
if (sample_type & PERF_SAMPLE_TRANSACTION) printf("... transaction: %" PRIx64 "\n", sample->transaction);
if (sample_type & PERF_SAMPLE_READ) sample_read__printf(sample, evsel->core.attr.read_format);}
static void dump_deferred_callchain(union perf_event *event, struct perf_sample *sample){ struct evsel *evsel = sample->evsel;
if (!dump_trace) return;
printf("(IP, 0x%x): %d/%d: %#" PRIx64 "\n", event->header.misc, sample->pid, sample->tid, sample->deferred_cookie);
if (evsel__has_callchain(evsel)) callchain__printf(evsel, sample);}
static void dump_read(struct evsel *evsel, union perf_event *event){ u64 read_format; __u64 *array; void *end;
if (!dump_trace) return;
printf(": %d %d %s %" PRI_lu64 "\n", event->read.pid, event->read.tid, evsel__name(evsel), event->read.value);
if (!evsel) return;
read_format = evsel->core.attr.read_format; /* * The kernel packs only the enabled read_format fields * after value, with no gaps. Walk the packed array * instead of using fixed struct offsets. */ array = &event->read.value + 1; end = (void *)event + event->header.size;
if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) { if ((void *)(array + 1) > end) return; printf("... time enabled : %" PRI_lu64 "\n", *array++); }
if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) { if ((void *)(array + 1) > end) return; printf("... time running : %" PRI_lu64 "\n", *array++); }
if (read_format & PERF_FORMAT_ID) { if ((void *)(array + 1) > end) return; printf("... id : %" PRI_lu64 "\n", *array++); }
if (read_format & PERF_FORMAT_LOST) { if ((void *)(array + 1) > end) return; printf("... lost : %" PRI_lu64 "\n", *array++); }}
static struct machine *machines__find_for_cpumode(struct machines *machines, union perf_event *event, struct perf_sample *sample){ if (perf_guest && ((sample->cpumode == PERF_RECORD_MISC_GUEST_KERNEL) || (sample->cpumode == PERF_RECORD_MISC_GUEST_USER))) { u32 pid;
if (sample->machine_pid) pid = sample->machine_pid; else if (event->header.type == PERF_RECORD_MMAP || event->header.type == PERF_RECORD_MMAP2) pid = event->mmap.pid; else pid = sample->pid;
/* * Guest code machine is created as needed and does not use * DEFAULT_GUEST_KERNEL_ID. */ if (symbol_conf.guest_code) return machines__findnew(machines, pid);
return machines__find_guest(machines, pid); }
return &machines->host;}
static int deliver_sample_value(struct evlist *evlist, const struct perf_tool *tool, union perf_event *event, struct perf_sample *sample, struct sample_read_value *v, struct machine *machine, bool per_thread){ struct perf_sample_id *sid = evlist__id2sid(evlist, v->id); struct evsel *saved_evsel = sample->evsel; u64 *storage = NULL; int ret;
if (sid) { storage = perf_sample_id__get_period_storage(sid, sample->tid, per_thread); }
if (storage) { sample->id = v->id; sample->period = v->value - *storage; *storage = v->value; }
if (!storage || sid->evsel == NULL) { ++evlist->stats.nr_unknown_id; return 0; }
/* * There's no reason to deliver sample * for zero period, bail out. */ if (!sample->period) return 0;
sample->evsel = container_of(sid->evsel, struct evsel, core); ret = tool->sample(tool, event, sample, machine); sample->evsel = saved_evsel; return ret;}
static int deliver_sample_group(struct evlist *evlist, const struct perf_tool *tool, union perf_event *event, struct perf_sample *sample, struct machine *machine, u64 read_format, bool per_thread){ int ret = -EINVAL; struct sample_read_value *v = sample->read.group.values;
if (tool->dont_split_sample_group) return deliver_sample_value(evlist, tool, event, sample, v, machine, per_thread);
sample_read_group__for_each(v, sample->read.group.nr, read_format) { ret = deliver_sample_value(evlist, tool, event, sample, v, machine, per_thread); if (ret) break; }
return ret;}
static int evlist__deliver_sample(struct evlist *evlist, const struct perf_tool *tool, union perf_event *event, struct perf_sample *sample, struct machine *machine){ struct evsel *evsel = sample->evsel; /* We know evsel != NULL. */ u64 sample_type = evsel->core.attr.sample_type; u64 read_format = evsel->core.attr.read_format; bool per_thread = perf_evsel__attr_has_per_thread_sample_period(&evsel->core);
/* Standard sample delivery. */ if (!(sample_type & PERF_SAMPLE_READ)) return tool->sample(tool, event, sample, machine);
/* For PERF_SAMPLE_READ we have either single or group mode. */ if (read_format & PERF_FORMAT_GROUP) return deliver_sample_group(evlist, tool, event, sample, machine, read_format, per_thread); else return deliver_sample_value(evlist, tool, event, sample, &sample->read.one, machine, per_thread);}
/* * Samples with deferred callchains should wait for the next matching * PERF_RECORD_CALLCHAIN_RECORD entries. Keep the events in a list and * deliver them once it finds the callchains. */struct deferred_event { struct list_head list; union perf_event *event; u64 file_offset;};
/* * This is called when a deferred callchain record comes up. Find all matching * samples, merge the callchains and process them. */static int evlist__deliver_deferred_callchain(struct evlist *evlist, const struct perf_tool *tool, union perf_event *event, struct perf_sample *sample, struct machine *machine){ struct deferred_event *de, *tmp; int ret = 0;
if (!tool->merge_deferred_callchains) { struct evsel *saved_evsel = sample->evsel;
sample->evsel = evlist__id2evsel(evlist, sample->id); ret = tool->callchain_deferred(tool, event, sample, machine); sample->evsel = saved_evsel; return ret; }
list_for_each_entry_safe(de, tmp, &evlist->deferred_samples, list) { struct perf_sample orig_sample;
perf_sample__init(&orig_sample, /*all=*/false); ret = evlist__parse_sample(evlist, de->event, &orig_sample); if (ret < 0) { pr_err("failed to parse original sample\n"); perf_sample__exit(&orig_sample); break; } orig_sample.file_offset = de->file_offset;
if (sample->tid != orig_sample.tid) { perf_sample__exit(&orig_sample); continue; }
if (event->callchain_deferred.cookie == orig_sample.deferred_cookie) sample__merge_deferred_callchain(&orig_sample, sample); else orig_sample.deferred_callchain = false;
orig_sample.evsel = evlist__id2evsel(evlist, orig_sample.id); ret = evlist__deliver_sample(evlist, tool, de->event, &orig_sample, machine);
perf_sample__exit(&orig_sample); list_del(&de->list); free(de->event); free(de);
if (ret) break; } return ret;}
/* * This is called at the end of the data processing for the session. Flush the * remaining samples as there's no hope for matching deferred callchains. */static int session__flush_deferred_samples(struct perf_session *session, const struct perf_tool *tool){ struct evlist *evlist = session->evlist; struct machine *machine = &session->machines.host; struct deferred_event *de, *tmp; int ret = 0;
list_for_each_entry_safe(de, tmp, &evlist->deferred_samples, list) { struct perf_sample sample;
perf_sample__init(&sample, /*all=*/false); ret = evlist__parse_sample(evlist, de->event, &sample); if (ret < 0) { pr_err("failed to parse original sample\n"); perf_sample__exit(&sample); break; } sample.file_offset = de->file_offset;
sample.evsel = evlist__id2evsel(evlist, sample.id); ret = evlist__deliver_sample(evlist, tool, de->event, &sample, machine);
perf_sample__exit(&sample); list_del(&de->list); free(de->event); free(de);
if (ret) break; } return ret;}
/* * Return true if the string field is properly null-terminated * within the event boundary. Native-endian files are mapped * read-only (MAP_SHARED + PROT_READ) so we cannot write a * null byte in place; skip the event instead. */static bool perf_event__check_nul(const char *str, const void *end, const char *event_name, u64 file_offset){ size_t max_len = (const char *)end - str;
if (max_len == 0 || strnlen(str, max_len) == max_len) { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_%s: string not null-terminated, skipping event\n", file_offset, event_name); return false; }
return true;}
static int machines__deliver_event(struct machines *machines, struct evlist *evlist, union perf_event *event, struct perf_sample *sample, const struct perf_tool *tool, u64 file_offset, const char *file_path){ struct machine *machine;
dump_event(evlist, event, file_offset, sample, file_path);
if (!sample->evsel) sample->evsel = evlist__id2evsel(evlist, sample->id); else assert(sample->evsel == evlist__id2evsel(evlist, sample->id));
machine = machines__find_for_cpumode(machines, event, sample);
switch (event->header.type) { case PERF_RECORD_SAMPLE: if (sample->evsel == NULL) { ++evlist->stats.nr_unknown_id; return 0; } if (machine == NULL) { ++evlist->stats.nr_unprocessable_samples; dump_sample(machine, event, sample); return 0; } dump_sample(machine, event, sample); if (sample->deferred_callchain && tool->merge_deferred_callchains) { struct deferred_event *de = malloc(sizeof(*de)); size_t sz = event->header.size;
if (de == NULL) return -ENOMEM;
de->event = malloc(sz); if (de->event == NULL) { free(de); return -ENOMEM; } memcpy(de->event, event, sz); de->file_offset = sample->file_offset; list_add_tail(&de->list, &evlist->deferred_samples); return 0; } return evlist__deliver_sample(evlist, tool, event, sample, machine); case PERF_RECORD_MMAP: if (!perf_event__check_nul(event->mmap.filename, (void *)event + event->header.size, "MMAP", file_offset)) return 0; return tool->mmap(tool, event, sample, machine); case PERF_RECORD_MMAP2: if (event->header.misc & PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT) ++evlist->stats.nr_proc_map_timeout; if (!perf_event__check_nul(event->mmap2.filename, (void *)event + event->header.size, "MMAP2", file_offset)) return 0; return tool->mmap2(tool, event, sample, machine); case PERF_RECORD_COMM: if (!perf_event__check_nul(event->comm.comm, (void *)event + event->header.size, "COMM", file_offset)) return 0; return tool->comm(tool, event, sample, machine); case PERF_RECORD_NAMESPACES: { /* * Cannot underflow: perf_event__min_size[] guarantees header.size >= sizeof. * Includes trailing sample_id space when present, but prevents OOB. */ u64 max_nr = (event->header.size - sizeof(event->namespaces)) / sizeof(event->namespaces.link_info[0]);
/* * Native-endian events are mmap'd read-only, so we * cannot clamp nr in place. Skip the event instead. * The swap handler already clamps on the writable * cross-endian path. */ if (event->namespaces.nr_namespaces > max_nr) { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_NAMESPACES: nr_namespaces %" PRIu64 " exceeds payload (max %" PRIu64 "), skipping\n", file_offset, (u64)event->namespaces.nr_namespaces, max_nr); return 0; } return tool->namespaces(tool, event, sample, machine); } case PERF_RECORD_CGROUP: if (!perf_event__check_nul(event->cgroup.path, (void *)event + event->header.size, "CGROUP", file_offset)) return 0; return tool->cgroup(tool, event, sample, machine); case PERF_RECORD_FORK: return tool->fork(tool, event, sample, machine); case PERF_RECORD_EXIT: return tool->exit(tool, event, sample, machine); case PERF_RECORD_LOST: if (tool->lost == perf_event__process_lost) evlist->stats.total_lost += event->lost.lost; return tool->lost(tool, event, sample, machine); case PERF_RECORD_LOST_SAMPLES: if (event->header.misc & PERF_RECORD_MISC_LOST_SAMPLES_BPF) evlist->stats.total_dropped_samples += event->lost_samples.lost; else if (tool->lost_samples == perf_event__process_lost_samples) evlist->stats.total_lost_samples += event->lost_samples.lost; return tool->lost_samples(tool, event, sample, machine); case PERF_RECORD_READ: dump_read(sample->evsel, event); return tool->read(tool, event, sample, machine); case PERF_RECORD_THROTTLE: return tool->throttle(tool, event, sample, machine); case PERF_RECORD_UNTHROTTLE: return tool->unthrottle(tool, event, sample, machine); case PERF_RECORD_AUX: if (tool->aux == perf_event__process_aux) { if (event->aux.flags & PERF_AUX_FLAG_TRUNCATED) evlist->stats.total_aux_lost += 1; if (event->aux.flags & PERF_AUX_FLAG_PARTIAL) evlist->stats.total_aux_partial += 1; if (event->aux.flags & PERF_AUX_FLAG_COLLISION) evlist->stats.total_aux_collision += 1; } return tool->aux(tool, event, sample, machine); case PERF_RECORD_ITRACE_START: return tool->itrace_start(tool, event, sample, machine); case PERF_RECORD_SWITCH: case PERF_RECORD_SWITCH_CPU_WIDE: return tool->context_switch(tool, event, sample, machine); case PERF_RECORD_KSYMBOL: if (!perf_event__check_nul(event->ksymbol.name, (void *)event + event->header.size, "KSYMBOL", file_offset)) return 0; return tool->ksymbol(tool, event, sample, machine); case PERF_RECORD_BPF_EVENT: return tool->bpf(tool, event, sample, machine); case PERF_RECORD_TEXT_POKE: { /* offsetof(bytes), not sizeof — sizeof includes padding past the flexible array */ size_t text_poke_len = offsetof(struct perf_record_text_poke_event, bytes) + event->text_poke.old_len + event->text_poke.new_len;
if (event->header.size < text_poke_len) { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_TEXT_POKE: old_len+new_len exceeds event, skipping\n", file_offset); return 0; } return tool->text_poke(tool, event, sample, machine); } case PERF_RECORD_AUX_OUTPUT_HW_ID: return tool->aux_output_hw_id(tool, event, sample, machine); case PERF_RECORD_CALLCHAIN_DEFERRED: dump_deferred_callchain(event, sample); return evlist__deliver_deferred_callchain(evlist, tool, event, sample, machine); default: ++evlist->stats.nr_unknown_events; return -1; }}
static int perf_session__deliver_event(struct perf_session *session, union perf_event *event, const struct perf_tool *tool, u64 file_offset, const char *file_path){ struct perf_sample sample; struct evsel *evsel; int ret;
perf_sample__init(&sample, /*all=*/false); evsel = evlist__event2evsel(session->evlist, event); if (!evsel) { pr_err("ERROR: at offset %#" PRIx64 ": no evsel found for %s (%u) event\n", file_offset, perf_event__name(event->header.type), event->header.type); ret = -EFAULT; goto out; } ret = evsel__parse_sample(evsel, event, &sample); if (ret) { pr_err("ERROR: at offset %#" PRIx64 ": can't parse %s (%u) sample, err = %d\n", file_offset, perf_event__name(event->header.type), event->header.type, ret); goto out; } sample.file_offset = file_offset; /* * evsel__parse_sample() doesn't populate machine_pid/vcpu, * which are needed by machines__find_for_cpumode() to * attribute samples to guest VMs. The SID table maps * sample IDs to the guest that owns the event. */ if (perf_guest && sample.id) { struct perf_sample_id *sid = evlist__id2sid(session->evlist, sample.id);
if (sid) { sample.machine_pid = sid->machine_pid; sample.vcpu = sid->vcpu.cpu; } }
/* * Validate sample.cpu before any callback can use it as an * array index (kwork cpus_runtime, timechart cpus_cstate_*, * sched cpu_last_switched). * * When PERF_SAMPLE_CPU is absent, evsel__parse_sample() leaves * sample.cpu as (u32)-1 — a sentinel that downstream tools * (script, inject) check to identify events without CPU info. * Only check when sample.cpu was actually populated from event * data: PERF_RECORD_SAMPLE always has it when PERF_SAMPLE_CPU * is set; non-sample events only have it when sample_id_all is * enabled. Otherwise sample.cpu is the (u32)-1 sentinel from * evsel__parse_sample() and must not be validated or clamped. */ if ((evsel->core.attr.sample_type & PERF_SAMPLE_CPU) && (event->header.type == PERF_RECORD_SAMPLE || evsel->core.attr.sample_id_all)) { int nr_cpus_avail = perf_session__env(session)->nr_cpus_avail;
/* * For perf.data files the MAX_NR_CPUS fallback in * perf_session__read_header() guarantees this is set. * For pipe mode, HEADER_NRCPUS may arrive late or not * at all (pre-2017 perf, third-party tools). Fall * back to MAX_NR_CPUS so the bounds check still works * against fixed-size downstream arrays. * * Do NOT write back to env: this function runs during * recording (synthesized events) when nr_cpus_avail is * legitimately 0. Writing MAX_NR_CPUS would cause * write_cpu_topology() to emit 4096 core_id/socket_id * pairs instead of the real CPU count, corrupting the * topology section in the generated perf.data. */ if (nr_cpus_avail <= 0) nr_cpus_avail = MAX_NR_CPUS; /* * Cap at MAX_NR_CPUS for the bounds check — downstream * consumers use fixed-size arrays of that size. Keep * the true nr_cpus_avail in env for header parsing * (e.g. process_cpu_topology) which needs the real count. */ if (nr_cpus_avail > MAX_NR_CPUS) nr_cpus_avail = MAX_NR_CPUS; if (sample.cpu >= (u32)nr_cpus_avail && sample.cpu != (u32)-1) { /* * Warn rather than abort: synthesized events * (MMAP, COMM) lack sample_id_all data, so * parse_id_sample reads garbage from the event * payload. Clamping to 0 protects downstream * array indexing while keeping the session alive. * * Preserve (u32)-1: perf script and perf inject * use it as a sentinel for "CPU not applicable." * Downstream array users (timechart, kwork) have * their own per-callback bounds checks. */ pr_warning_once("WARNING: at offset %#" PRIx64 ": sample CPU %u >= nr_cpus_avail %u, clamping to 0\n", file_offset, sample.cpu, nr_cpus_avail); sample.cpu = 0; } }
ret = auxtrace__process_event(session, event, &sample, tool); if (ret < 0) goto out; if (ret > 0) { ret = 0; goto out; }
ret = machines__deliver_event(&session->machines, session->evlist, event, &sample, tool, file_offset, file_path);
if (dump_trace && sample.aux_sample.size) auxtrace__dump_auxtrace_sample(session, &sample);out: perf_sample__exit(&sample); return ret;}
static s64 perf_session__process_user_event(struct perf_session *session, union perf_event *event, u64 file_offset, const char *file_path){ struct ordered_events *oe = &session->ordered_events; const struct perf_tool *tool = session->tool; const u32 event_size = READ_ONCE(event->header.size); struct perf_sample sample; int fd = perf_data__fd(session->data); s64 err;
perf_sample__init(&sample, /*all=*/true); if ((event->header.type != PERF_RECORD_COMPRESSED && event->header.type != PERF_RECORD_COMPRESSED2) || perf_tool__compressed_is_stub(tool)) dump_event(session->evlist, event, file_offset, &sample, file_path);
/* These events are processed right away */ switch (event->header.type) { case PERF_RECORD_HEADER_ATTR: err = tool->attr(tool, event, &session->evlist); if (err == 0) { perf_session__set_id_hdr_size(session); perf_session__set_comm_exec(session); } break; case PERF_RECORD_EVENT_UPDATE: err = tool->event_update(tool, event, &session->evlist); break; case PERF_RECORD_HEADER_EVENT_TYPE: /* * Deprecated, but we need to handle it for sake * of old data files create in pipe mode. */ err = 0; break; case PERF_RECORD_HEADER_TRACING_DATA: /* * Setup for reading amidst mmap, but only when we * are in 'file' mode. The 'pipe' fd is in proper * place already. */ if (!perf_data__is_pipe(session->data)) lseek(fd, file_offset, SEEK_SET); err = tool->tracing_data(tool, session, event); break; case PERF_RECORD_HEADER_BUILD_ID: if (!perf_event__check_nul(event->build_id.filename, (void *)event + event_size, "HEADER_BUILD_ID", file_offset)) { err = 0; break; } err = tool->build_id(tool, session, event); break; case PERF_RECORD_FINISHED_ROUND: err = tool->finished_round(tool, event, oe); break; case PERF_RECORD_ID_INDEX: err = tool->id_index(tool, session, event); break; case PERF_RECORD_AUXTRACE_INFO: err = tool->auxtrace_info(tool, session, event); break; case PERF_RECORD_AUXTRACE: /* * Setup for reading amidst mmap, but only when we * are in 'file' mode. The 'pipe' fd is in proper * place already. */ if (!perf_data__is_pipe(session->data)) lseek(fd, file_offset + event_size, SEEK_SET); err = tool->auxtrace(tool, session, event); break; case PERF_RECORD_AUXTRACE_ERROR: perf_session__auxtrace_error_inc(session, event); err = tool->auxtrace_error(tool, session, event); break; case PERF_RECORD_THREAD_MAP: { u64 max_nr;
if (event_size < sizeof(event->thread_map)) { pr_err("ERROR: at offset %#" PRIx64 ": PERF_RECORD_THREAD_MAP: header.size (%u) too small\n", file_offset, event_size); err = -EINVAL; break; }
max_nr = (event_size - sizeof(event->thread_map)) / sizeof(event->thread_map.entries[0]); if (event->thread_map.nr > max_nr) { pr_err("ERROR: at offset %#" PRIx64 ": PERF_RECORD_THREAD_MAP: nr %" PRIu64 " exceeds max %" PRIu64 "\n", file_offset, (u64)event->thread_map.nr, max_nr); err = -EINVAL; break; }
err = tool->thread_map(tool, session, event); break; } case PERF_RECORD_CPU_MAP: { struct perf_record_cpu_map_data *data = &event->cpu_map.data; u32 payload = event_size - sizeof(event->header);
/* * Native-endian events are mmap'd read-only, so we * cannot clamp nr fields in place. Skip the event * if any variant overflows. */ switch (data->type) { case PERF_CPU_MAP__CPUS: { u16 max_nr = (payload - offsetof(struct perf_record_cpu_map_data, cpus_data.cpu)) / sizeof(data->cpus_data.cpu[0]);
if (data->cpus_data.nr > max_nr) { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_CPU_MAP: nr %u exceeds payload (max %u), skipping\n", file_offset, data->cpus_data.nr, max_nr); err = 0; goto out; } break; } case PERF_CPU_MAP__MASK: if (data->mask32_data.long_size == 4) { u16 max_nr = (payload - offsetof(struct perf_record_cpu_map_data, mask32_data.mask)) / sizeof(data->mask32_data.mask[0]);
if (data->mask32_data.nr > max_nr) { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_CPU_MAP mask32: nr %u exceeds payload (max %u), skipping\n", file_offset, data->mask32_data.nr, max_nr); err = 0; goto out; } } else if (data->mask64_data.long_size == 8) { u16 max_nr;
if (payload < offsetof(struct perf_record_cpu_map_data, mask64_data.mask)) { err = 0; goto out; } max_nr = (payload - offsetof(struct perf_record_cpu_map_data, mask64_data.mask)) / sizeof(data->mask64_data.mask[0]); if (data->mask64_data.nr > max_nr) { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_CPU_MAP mask64: nr %u exceeds payload (max %u), skipping\n", file_offset, data->mask64_data.nr, max_nr); err = 0; goto out; } } else { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_CPU_MAP: unsupported long_size %u, skipping\n", file_offset, data->mask32_data.long_size); err = 0; goto out; } break; default: break; }
err = tool->cpu_map(tool, session, event); break; } case PERF_RECORD_STAT_CONFIG: { /* Cannot underflow: perf_event__min_size[] guarantees event_size >= sizeof */ u64 max_nr = (event_size - sizeof(event->stat_config)) / sizeof(event->stat_config.data[0]);
/* * Native-endian events are mmap'd read-only, so we * cannot clamp nr in place. Skip the event instead. */ if (event->stat_config.nr > max_nr) { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_STAT_CONFIG: nr %" PRIu64 " exceeds payload (max %" PRIu64 "), skipping\n", file_offset, (u64)event->stat_config.nr, max_nr); err = 0; goto out; }
err = tool->stat_config(tool, session, event); break; } case PERF_RECORD_STAT: err = tool->stat(tool, session, event); break; case PERF_RECORD_STAT_ROUND: err = tool->stat_round(tool, session, event); break; case PERF_RECORD_TIME_CONV: /* * Bounded copy: older kernels emit a shorter struct * without time_cycles/time_mask/cap_user_time_*. * Zero the rest so extended fields default to off. */ memset(&session->time_conv, 0, sizeof(session->time_conv)); memcpy(&session->time_conv, &event->time_conv, min((size_t)event_size, sizeof(session->time_conv))); err = tool->time_conv(tool, session, event); break; case PERF_RECORD_HEADER_FEATURE: err = tool->feature(tool, session, event); break; case PERF_RECORD_COMPRESSED: case PERF_RECORD_COMPRESSED2: err = tool->compressed(tool, session, event, file_offset, file_path); if (err) dump_event(session->evlist, event, file_offset, &sample, file_path); break; case PERF_RECORD_FINISHED_INIT: err = tool->finished_init(tool, session, event); break; case PERF_RECORD_BPF_METADATA: { u64 nr_entries, max_entries;
if (event_size < sizeof(event->bpf_metadata)) { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_BPF_METADATA: header.size (%u) too small, skipping\n", file_offset, event_size); err = 0; break; }
/* * Native-endian files are mmap'd read-only — validate * NUL-termination instead of writing. */ if (strnlen(event->bpf_metadata.prog_name, BPF_PROG_NAME_LEN) == BPF_PROG_NAME_LEN) { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_BPF_METADATA: prog_name not null-terminated, skipping\n", file_offset); err = 0; break; }
nr_entries = READ_ONCE(event->bpf_metadata.nr_entries); max_entries = (event_size - sizeof(event->bpf_metadata)) / sizeof(event->bpf_metadata.entries[0]); if (nr_entries > max_entries) { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_BPF_METADATA: nr_entries %" PRIu64 " exceeds max %" PRIu64 ", skipping\n", file_offset, nr_entries, max_entries); err = 0; break; }
for (u64 i = 0; i < nr_entries; i++) { if (strnlen(event->bpf_metadata.entries[i].key, BPF_METADATA_KEY_LEN) == BPF_METADATA_KEY_LEN || strnlen(event->bpf_metadata.entries[i].value, BPF_METADATA_VALUE_LEN) == BPF_METADATA_VALUE_LEN) { pr_warning("WARNING: at offset %#" PRIx64 ": PERF_RECORD_BPF_METADATA: entry %" PRIu64 " key/value not null-terminated, skipping\n", file_offset, i); err = 0; goto out; } }
err = tool->bpf_metadata(tool, session, event); break; } case PERF_RECORD_SCHEDSTAT_CPU: err = tool->schedstat_cpu(tool, session, event); break; case PERF_RECORD_SCHEDSTAT_DOMAIN: err = tool->schedstat_domain(tool, session, event); break; default: err = -EINVAL; break; }out: perf_sample__exit(&sample); return err;}
int perf_session__deliver_synth_event(struct perf_session *session, union perf_event *event, struct perf_sample *sample){ struct evlist *evlist = session->evlist; const struct perf_tool *tool = session->tool;
events_stats__inc(&evlist->stats, event->header.type);
if (event->header.type >= PERF_RECORD_USER_TYPE_START) return perf_session__process_user_event(session, event, 0, NULL);
return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0, NULL);}
int perf_session__deliver_synth_attr_event(struct perf_session *session, const struct perf_event_attr *attr, u64 id){ union { struct { struct perf_record_header_attr attr; u64 ids[1]; } attr_id; union perf_event ev; } ev = { .attr_id.attr.header.type = PERF_RECORD_HEADER_ATTR, .attr_id.attr.header.size = sizeof(ev.attr_id), .attr_id.ids[0] = id, };
if (attr->size != sizeof(ev.attr_id.attr.attr)) { pr_debug("Unexpected perf_event_attr size\n"); return -EINVAL; } ev.attr_id.attr.attr = *attr; return perf_session__deliver_synth_event(session, &ev.ev, NULL);}
/* Caller must ensure event->header.type < PERF_RECORD_HEADER_MAX */static int event_swap(union perf_event *event, bool sample_id_all){ perf_event__swap_op swap = perf_event__swap_ops[event->header.type];
if (swap) return swap(event, sample_id_all); return 0;}
/* * Minimum event sizes indexed by type. Checked before swap and * processing so that both cross-endian and native-endian paths * are protected from accessing fields past the event boundary. * Zero means no minimum beyond the 8-byte header (already * enforced by the reader). * * These values represent the smallest event the kernel has ever * emitted for each type, so they do not reject legitimate legacy * perf.data files from older kernels. Variable-length events * use offsetof() to the first variable field; the variable * content is validated separately (e.g., perf_event__check_nul). */static const u32 perf_event__min_size[PERF_RECORD_HEADER_MAX] = { /* * offsetof() + 1 for types with a trailing variable-length * string (filename, comm, path, name, msg): the +1 ensures * room for at least a null terminator. Full null-termination * within the event boundary is checked separately. * * PERF_RECORD_SAMPLE is omitted: all64_swap is bounded by * header.size, and the internal layout varies by sample_type * so a fixed minimum is not meaningful. */ [PERF_RECORD_MMAP] = offsetof(struct perf_record_mmap, filename) + 1, [PERF_RECORD_LOST] = sizeof(struct perf_record_lost), [PERF_RECORD_COMM] = offsetof(struct perf_record_comm, comm) + 1, [PERF_RECORD_EXIT] = sizeof(struct perf_record_fork), [PERF_RECORD_THROTTLE] = sizeof(struct perf_record_throttle), [PERF_RECORD_UNTHROTTLE] = sizeof(struct perf_record_throttle), [PERF_RECORD_FORK] = sizeof(struct perf_record_fork), /* * The kernel dynamically sizes PERF_RECORD_READ based on * attr.read_format — only the enabled fields are emitted, * packed with no gaps. The minimum valid event has just * pid + tid + one u64 value (no optional fields). */ [PERF_RECORD_READ] = offsetof(struct perf_record_read, time_enabled), [PERF_RECORD_MMAP2] = offsetof(struct perf_record_mmap2, filename) + 1, [PERF_RECORD_LOST_SAMPLES] = sizeof(struct perf_record_lost_samples), [PERF_RECORD_AUX] = sizeof(struct perf_record_aux), [PERF_RECORD_ITRACE_START] = sizeof(struct perf_record_itrace_start), [PERF_RECORD_SWITCH] = sizeof(struct perf_event_header), [PERF_RECORD_SWITCH_CPU_WIDE] = sizeof(struct perf_record_switch), [PERF_RECORD_NAMESPACES] = sizeof(struct perf_record_namespaces), [PERF_RECORD_CGROUP] = offsetof(struct perf_record_cgroup, path) + 1, [PERF_RECORD_TEXT_POKE] = sizeof(struct perf_record_text_poke_event), [PERF_RECORD_KSYMBOL] = offsetof(struct perf_record_ksymbol, name) + 1, [PERF_RECORD_BPF_EVENT] = sizeof(struct perf_record_bpf_event), [PERF_RECORD_HEADER_ATTR] = sizeof(struct perf_event_header) + PERF_ATTR_SIZE_VER0, [PERF_RECORD_HEADER_EVENT_TYPE] = sizeof(struct perf_record_header_event_type), /* Legacy events predate the __u32 pad field, accept 12-byte records */ [PERF_RECORD_HEADER_TRACING_DATA] = offsetof(struct perf_record_header_tracing_data, pad), [PERF_RECORD_AUX_OUTPUT_HW_ID] = sizeof(struct perf_record_aux_output_hw_id), [PERF_RECORD_AUXTRACE_INFO] = sizeof(struct perf_record_auxtrace_info), [PERF_RECORD_AUXTRACE] = sizeof(struct perf_record_auxtrace), [PERF_RECORD_AUXTRACE_ERROR] = offsetof(struct perf_record_auxtrace_error, msg) + 1, [PERF_RECORD_THREAD_MAP] = sizeof(struct perf_record_thread_map), /* * sizeof(perf_record_cpu_map) is 20 because the outer struct * isn't packed and GCC adds 2 bytes of trailing padding. * The smallest valid variant (RANGE_CPUS) is only 16 bytes: * header(8) + type(2) + range_cpu_data(6). Per-variant * bounds are checked in the swap handler via payload. */ [PERF_RECORD_CPU_MAP] = sizeof(struct perf_event_header) + sizeof(__u16) + sizeof(struct perf_record_range_cpu_map), [PERF_RECORD_STAT_CONFIG] = sizeof(struct perf_record_stat_config), [PERF_RECORD_STAT] = sizeof(struct perf_record_stat), [PERF_RECORD_STAT_ROUND] = sizeof(struct perf_record_stat_round), /* * EVENT_UPDATE has a union whose largest member (cpus) * inflates sizeof to 40, but SCALE events are only 32 * and UNIT/NAME events can be even smaller. Use the * fixed header fields (header + type + id) as minimum. */ [PERF_RECORD_EVENT_UPDATE] = offsetof(struct perf_record_event_update, scale), [PERF_RECORD_TIME_CONV] = offsetof(struct perf_record_time_conv, time_cycles), [PERF_RECORD_ID_INDEX] = sizeof(struct perf_record_id_index), [PERF_RECORD_HEADER_BUILD_ID] = sizeof(struct perf_record_header_build_id), [PERF_RECORD_HEADER_FEATURE] = sizeof(struct perf_record_header_feature), [PERF_RECORD_COMPRESSED2] = sizeof(struct perf_record_compressed2), [PERF_RECORD_BPF_METADATA] = sizeof(struct perf_record_bpf_metadata), [PERF_RECORD_CALLCHAIN_DEFERRED] = sizeof(struct perf_event_header) + sizeof(__u64), /* * SCHEDSTAT events have a version-dependent union after the * fixed header fields; the minimum is the base (pre-union) * portion so old and new versions both pass. */ [PERF_RECORD_SCHEDSTAT_CPU] = offsetof(struct perf_record_schedstat_cpu, v15), [PERF_RECORD_SCHEDSTAT_DOMAIN] = offsetof(struct perf_record_schedstat_domain, v15),};
/* * Return true if the event is too small for its declared type. * Caller must ensure event->header.type < PERF_RECORD_HEADER_MAX. * If min is non-NULL, stores the required minimum on failure. */static bool perf_event__too_small(const union perf_event *event, u32 *min){ u32 min_sz = perf_event__min_size[event->header.type];
if (min_sz && event->header.size < min_sz) { if (min) *min = min_sz; return true; }
return false;}
/* * Read and validate the event at @file_offset. * * Returns: * 0 — success: *event_ptr is set and safe to access. * -1 — error; check *event_ptr to decide whether to advance or abort: * *event_ptr set — event header was read but the event is * malformed (too small for its type, or byte-swap * failed). header.size is still valid, so the * caller can advance past the event. * *event_ptr NULL — fatal: couldn't read the header at all * (I/O error, offset out of range, pipe mode). * Caller must abort. */int perf_session__peek_event(struct perf_session *session, off_t file_offset, void *buf, size_t buf_sz, union perf_event **event_ptr, struct perf_sample *sample){ union perf_event *event; size_t hdr_sz, rest; u32 min_sz; int fd;
*event_ptr = NULL;
if (session->one_mmap && !session->header.needs_swap) { u64 offset_in_mmap;
/* Validate offset with integer arithmetic to avoid pointer UB */ if ((u64)file_offset < session->one_mmap_offset) return -1;
offset_in_mmap = (u64)file_offset - session->one_mmap_offset;
/* Use subtraction to avoid addition overflow */ if (offset_in_mmap >= session->one_mmap_size || session->one_mmap_size - offset_in_mmap < sizeof(struct perf_event_header)) return -1;
event = session->one_mmap_addr + offset_in_mmap;
if (event->header.size < sizeof(struct perf_event_header)) return -1;
/* Ensure full event is within the mmap region */ if (session->one_mmap_size - offset_in_mmap < event->header.size) return -1; } else { if (perf_data__is_pipe(session->data)) return -1;
fd = perf_data__fd(session->data); hdr_sz = sizeof(struct perf_event_header);
if (buf_sz < hdr_sz) return -1;
if (lseek(fd, file_offset, SEEK_SET) == (off_t)-1 || readn(fd, buf, hdr_sz) != (ssize_t)hdr_sz) return -1;
event = (union perf_event *)buf;
if (session->header.needs_swap) perf_event_header__bswap(&event->header);
if (event->header.size < hdr_sz || event->header.size > buf_sz) return -1;
buf += hdr_sz; rest = event->header.size - hdr_sz;
if (readn(fd, buf, rest) != (ssize_t)rest) return -1; }
/* Event data is fully loaded — expose so callers can advance */ *event_ptr = event;
/* * Check alignment before type: an unaligned size misaligns the * stream for all subsequent reads regardless of event type. * Three legacy user events predate the 8-byte rule — exempt them. */ if (event->header.size % sizeof(u64) && event->header.type != PERF_RECORD_HEADER_TRACING_DATA && event->header.type != PERF_RECORD_COMPRESSED && event->header.type != PERF_RECORD_HEADER_FEATURE) { pr_warning("WARNING: at offset %#" PRIx64 ": %s (%u) event size %u not aligned to %zu\n", (u64)file_offset, perf_event__name(event->header.type), event->header.type, event->header.size, sizeof(u64)); return -1; }
if (event->header.type >= PERF_RECORD_HEADER_MAX) { pr_warning("WARNING: at offset %#" PRIx64 ": unsupported event type %u, skipping\n", (u64)file_offset, event->header.type); return 0; }
if (perf_event__too_small(event, &min_sz)) { pr_warning("WARNING: at offset %#" PRIx64 ": %s (%u) event size %u too small (min %u)\n", (u64)file_offset, perf_event__name(event->header.type), event->header.type, event->header.size, min_sz); return -1; }
if (session->header.needs_swap && event_swap(event, evlist__sample_id_all(session->evlist))) { /* * The header was already swapped so header.size is * valid — expose the event so callers can advance * past this malformed entry instead of aborting. */ *event_ptr = event; return -1; }
if (sample && event->header.type < PERF_RECORD_USER_TYPE_START && evlist__parse_sample(session->evlist, event, sample)) return -1;
return 0;}
int perf_session__peek_events(struct perf_session *session, u64 offset, u64 size, peek_events_cb_t cb, void *data){ u64 max_offset = offset + size; char buf[PERF_SAMPLE_MAX_SIZE]; union perf_event *event; int err;
do { event = NULL; err = perf_session__peek_event(session, offset, buf, PERF_SAMPLE_MAX_SIZE, &event, NULL); if (err) { /* * Recoverable error: peek_event returns -1 but * sets event_ptr when the header was read * successfully but the event is malformed (too * small or swap failed). Skip past it using * header.size — don't invoke the callback since * type-specific fields may be truncated. * * Must abort if: event_ptr is NULL (I/O error), * size is 0 (can't advance), type is AUXTRACE * (payload extends beyond header.size), or size * is unaligned (would misalign all subsequent reads). * * Direct callers (auxtrace, cs-etm) treat any * non-zero return as fatal — only this loop skips. */ if (event && event->header.size && event->header.type != PERF_RECORD_AUXTRACE && event->header.size % sizeof(u64) == 0) { offset += event->header.size; err = 0; } else { return err; } continue; }
err = cb(session, event, offset, data); if (err) return err;
offset += event->header.size; if (event->header.type == PERF_RECORD_AUXTRACE) offset += event->auxtrace.size;
} while (offset < max_offset);
return err;}
static s64 perf_session__process_event(struct perf_session *session, union perf_event *event, u64 file_offset, const char *file_path){ struct evlist *evlist = session->evlist; const struct perf_tool *tool = session->tool; u32 min_sz; int ret;
/* * The kernel aligns all event sizes to sizeof(u64) — see * perf_event_comm_event() (ALIGN), perf_event_mmap_event(), * perf_event_cgroup(), perf_event_ksymbol() (IS_ALIGNED loops), * and perf_event_text_poke() (ALIGN) in kernel/events/core.c. * * An unaligned size means the file is corrupted or crafted. * Abort: there is no point continuing to read unaligned records * because the caller advances rd->head by event->header.size, * so every subsequent read would start at a misaligned offset, * producing garbage headers for the rest of the file. * * Exempt three legacy user events that predate the alignment rule: * * TRACING_DATA (66): struct tracing_data_event was 12 bytes before * b39c915a4f36 ("libperf event: Ensure tracing data is multiple * of 8 sized") added __u32 pad; old perf.data files still contain * 12-byte records. * TODO: introduce HEADER_TRACING_DATA2 with guaranteed alignment. * * COMPRESSED (81): raw ZSTD output, arbitrary length. Already * superseded by COMPRESSED2 (83) with PERF_ALIGN. * * HEADER_FEATURE (80): do_write_string() uses a 4-byte length * prefix with no padding to 8-byte total. * TODO: introduce HEADER_FEATURE2 with guaranteed alignment. */ if (event->header.size % sizeof(u64) && event->header.type != PERF_RECORD_HEADER_TRACING_DATA && event->header.type != PERF_RECORD_COMPRESSED && event->header.type != PERF_RECORD_HEADER_FEATURE) { pr_err("ERROR: at offset %#" PRIx64 ": %s (%u) event size %u is not 8-byte aligned, aborting\n", file_offset, perf_event__name(event->header.type), event->header.type, event->header.size); return -EINVAL; }
if (event->header.type >= PERF_RECORD_HEADER_MAX) { /* This perf is outdated and does not support the latest event type. */ ui__warning("Unsupported header type %u, please consider updating perf.\n", event->header.type); /* * Return 0 to skip: the caller (reader__read_event) * already advances by event->header.size. */ return 0; }
/* * Skip rather than abort: a too-small-but-aligned event * can be safely stepped over without misaligning the stream. */ if (perf_event__too_small(event, &min_sz)) { pr_warning("WARNING: at offset %#" PRIx64 ": %s (%u) event size %u too small (min %u), skipping\n", file_offset, perf_event__name(event->header.type), event->header.type, event->header.size, min_sz); return 0; }
if (session->header.needs_swap && event_swap(event, evlist__sample_id_all(evlist))) { pr_warning("WARNING: at offset %#" PRIx64 ": swap failed for %s (%u) event, skipping\n", file_offset, perf_event__name(event->header.type), event->header.type); return 0; }
events_stats__inc(&evlist->stats, event->header.type);
if (event->header.type >= PERF_RECORD_USER_TYPE_START) return perf_session__process_user_event(session, event, file_offset, file_path);
if (tool->ordered_events) { u64 timestamp = -1ULL;
ret = evlist__parse_sample_timestamp(evlist, event, ×tamp); if (ret && ret != -1) return ret;
ret = perf_session__queue_event(session, event, timestamp, file_offset, file_path); if (ret != -ETIME) return ret; }
return perf_session__deliver_event(session, event, tool, file_offset, file_path);}
void perf_event_header__bswap(struct perf_event_header *hdr){ hdr->type = bswap_32(hdr->type); hdr->misc = bswap_16(hdr->misc); hdr->size = bswap_16(hdr->size);}
struct thread *perf_session__findnew(struct perf_session *session, pid_t pid){ return machine__findnew_thread(&session->machines.host, -1, pid);}
int perf_session__register_idle_thread(struct perf_session *session){ struct thread *thread = machine__idle_thread(&session->machines.host);
/* machine__idle_thread() got the thread, so put it */ thread__put(thread); return thread ? 0 : -1;}
static voidperf_session__warn_order(const struct perf_session *session){ const struct ordered_events *oe = &session->ordered_events; struct evsel *evsel; bool should_warn = true;
evlist__for_each_entry(session->evlist, evsel) { if (evsel->core.attr.write_backward) should_warn = false; }
if (!should_warn) return; if (oe->nr_unordered_events != 0) ui__warning("%u out of order events recorded.\n", oe->nr_unordered_events);}
static void perf_session__warn_about_errors(const struct perf_session *session){ const struct events_stats *stats = &session->evlist->stats;
if (session->tool->lost == perf_event__process_lost && stats->nr_events[PERF_RECORD_LOST] != 0) { ui__warning("Processed %d events and lost %d chunks!\n\n" "Check IO/CPU overload!\n\n", stats->nr_events[0], stats->nr_events[PERF_RECORD_LOST]); }
if (session->tool->lost_samples == perf_event__process_lost_samples) { double drop_rate;
drop_rate = (double)stats->total_lost_samples / (double) (stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples); if (drop_rate > 0.05) { ui__warning("Processed %" PRIu64 " samples and lost %3.2f%%!\n\n", stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples, drop_rate * 100.0); } }
if (session->tool->aux == perf_event__process_aux && stats->total_aux_lost != 0) { ui__warning("AUX data lost %" PRIu64 " times out of %u!\n\n", stats->total_aux_lost, stats->nr_events[PERF_RECORD_AUX]); }
if (session->tool->aux == perf_event__process_aux && stats->total_aux_partial != 0) { bool vmm_exclusive = false;
(void)sysfs__read_bool("module/kvm_intel/parameters/vmm_exclusive", &vmm_exclusive);
ui__warning("AUX data had gaps in it %" PRIu64 " times out of %u!\n\n" "Are you running a KVM guest in the background?%s\n\n", stats->total_aux_partial, stats->nr_events[PERF_RECORD_AUX], vmm_exclusive ? "\nReloading kvm_intel module with vmm_exclusive=0\n" "will reduce the gaps to only guest's timeslices." : ""); }
if (session->tool->aux == perf_event__process_aux && stats->total_aux_collision != 0) { ui__warning("AUX data detected collision %" PRIu64 " times out of %u!\n\n", stats->total_aux_collision, stats->nr_events[PERF_RECORD_AUX]); }
if (stats->nr_unknown_events != 0) { ui__warning("Found %u unknown events!\n\n" "Is this an older tool processing a perf.data " "file generated by a more recent tool?\n\n" "If that is not the case, consider " "reporting to linux-kernel@vger.kernel.org.\n\n", stats->nr_unknown_events); }
if (stats->nr_unknown_id != 0) { ui__warning("%u samples with id not present in the header\n", stats->nr_unknown_id); }
if (stats->nr_invalid_chains != 0) { ui__warning("Found invalid callchains!\n\n" "%u out of %u events were discarded for this reason.\n\n" "Consider reporting to linux-kernel@vger.kernel.org.\n\n", stats->nr_invalid_chains, stats->nr_events[PERF_RECORD_SAMPLE]); }
if (stats->nr_unprocessable_samples != 0) { ui__warning("%u unprocessable samples recorded.\n" "Do you have a KVM guest running and not using 'perf kvm'?\n", stats->nr_unprocessable_samples); }
perf_session__warn_order(session);
events_stats__auxtrace_error_warn(stats);
if (stats->nr_proc_map_timeout != 0) { ui__warning("%d map information files for pre-existing threads were\n" "not processed, if there are samples for addresses they\n" "will not be resolved, you may find out which are these\n" "threads by running with -v and redirecting the output\n" "to a file.\n" "The time limit to process proc map is too short?\n" "Increase it by --proc-map-timeout\n", stats->nr_proc_map_timeout); }}
static int perf_session__flush_thread_stack(struct thread *thread, void *p __maybe_unused){ return thread_stack__flush(thread);}
static int perf_session__flush_thread_stacks(struct perf_session *session){ return machines__for_each_thread(&session->machines, perf_session__flush_thread_stack, NULL);}
volatile sig_atomic_t session_done;
static int __perf_session__process_decomp_events(struct perf_session *session);
static int __perf_session__process_pipe_events(struct perf_session *session){ struct ordered_events *oe = &session->ordered_events; const struct perf_tool *tool = session->tool; struct ui_progress prog; union perf_event *event; uint32_t size, cur_size = 0; void *buf = NULL; s64 skip = 0; u64 head; ssize_t err; void *p; bool update_prog = false;
/* * If it's from a file saving pipe data (by redirection), it would have * a file name other than "-". Then we can get the total size and show * the progress. */ if (strcmp(session->data->path, "-") && session->data->file.size) { ui_progress__init_size(&prog, session->data->file.size, "Processing events..."); update_prog = true; }
head = 0; cur_size = sizeof(union perf_event);
buf = malloc(cur_size); if (!buf) return -errno; ordered_events__set_copy_on_queue(oe, true);more: event = buf; err = perf_data__read(session->data, event, sizeof(struct perf_event_header)); if (err <= 0) { if (err == 0) goto done;
pr_err("failed to read event header\n"); goto out_err; }
if (session->header.needs_swap) perf_event_header__bswap(&event->header);
size = event->header.size; if (size < sizeof(struct perf_event_header)) { pr_err("bad event header size\n"); goto out_err; }
if (size > cur_size) { void *new = realloc(buf, size); if (!new) { pr_err("failed to allocate memory to read event\n"); goto out_err; } buf = new; cur_size = size; event = buf; } p = event; p += sizeof(struct perf_event_header);
if (size - sizeof(struct perf_event_header)) { err = perf_data__read(session->data, p, size - sizeof(struct perf_event_header)); if (err <= 0) { if (err == 0) { pr_err("unexpected end of event stream\n"); goto done; }
pr_err("failed to read event data\n"); goto out_err; } }
if ((skip = perf_session__process_event(session, event, head, "pipe")) < 0) { pr_err("%#" PRIx64 " [%#x]: piped event processing failed for event of type: %s (%d)\n", head, event->header.size, perf_event__name(event->header.type), event->header.type); err = -EINVAL; goto out_err; }
head += size;
if (skip > 0) head += skip;
err = __perf_session__process_decomp_events(session); if (err) goto out_err;
if (update_prog) ui_progress__update(&prog, size);
if (!session_done()) goto more;done: /* do the final flush for ordered samples */ err = ordered_events__flush(oe, OE_FLUSH__FINAL); if (err) goto out_err; err = session__flush_deferred_samples(session, tool); if (err) goto out_err; err = auxtrace__flush_events(session, tool); if (err) goto out_err; err = perf_session__flush_thread_stacks(session);out_err: free(buf); if (update_prog) ui_progress__finish(); if (!tool->no_warn) perf_session__warn_about_errors(session); ordered_events__free(&session->ordered_events); auxtrace__free_events(session); return err;}
static union perf_event *prefetch_event(char *buf, u64 head, size_t mmap_size, bool needs_swap, union perf_event *error){ union perf_event *event; u16 event_size;
/* * Ensure we have enough space remaining to read * the size of the event in the headers. */ if (head + sizeof(event->header) > mmap_size) return NULL;
event = (union perf_event *)(buf + head); if (needs_swap) perf_event_header__bswap(&event->header);
event_size = event->header.size; if (head + event_size <= mmap_size) return event;
/* We're not fetching the event so swap back again */ if (needs_swap) perf_event_header__bswap(&event->header);
/* Check if the event fits into the next mmapped buf. */ if (event_size <= mmap_size - head % page_size) { /* Remap buf and fetch again. */ return NULL; }
/* Invalid input. Event size should never exceed mmap_size. */ pr_debug("%s: head=%#" PRIx64 " event->header.size=%#x, mmap_size=%#zx:" " fuzzed or compressed perf.data?\n", __func__, head, event_size, mmap_size);
return error;}
static union perf_event *fetch_mmaped_event(u64 head, size_t mmap_size, char *buf, bool needs_swap){ return prefetch_event(buf, head, mmap_size, needs_swap, ERR_PTR(-EINVAL));}
static union perf_event *fetch_decomp_event(u64 head, size_t mmap_size, char *buf, bool needs_swap){ return prefetch_event(buf, head, mmap_size, needs_swap, NULL);}
static int __perf_session__process_decomp_events(struct perf_session *session){ s64 skip; u64 size; struct decomp *decomp = session->active_decomp->decomp_last;
if (!decomp) return 0;
while (decomp->head < decomp->size && !session_done()) { union perf_event *event = fetch_decomp_event(decomp->head, decomp->size, decomp->data, session->header.needs_swap);
if (!event) break;
size = event->header.size;
if (size < sizeof(struct perf_event_header) || (skip = perf_session__process_event(session, event, decomp->file_pos, decomp->file_path)) < 0) { pr_err("%#" PRIx64 " [%#x]: decompress event processing failed for event of type: %s (%d)\n", decomp->file_pos + decomp->head, event->header.size, perf_event__name(event->header.type), event->header.type); return -EINVAL; }
if (skip) size += skip;
decomp->head += size; }
return 0;}
/* * On 64bit we can mmap the data file in one go. No need for tiny mmap * slices. On 32bit we use 32MB. */#if BITS_PER_LONG == 64#define MMAP_SIZE ULLONG_MAX#define NUM_MMAPS 1#else#define MMAP_SIZE (32 * 1024 * 1024ULL)#define NUM_MMAPS 128#endif
struct reader;
typedef s64 (*reader_cb_t)(struct perf_session *session, union perf_event *event, u64 file_offset, const char *file_path);
struct reader { int fd; const char *path; u64 data_size; u64 data_offset; reader_cb_t process; bool in_place_update; char *mmaps[NUM_MMAPS]; size_t mmap_size; int mmap_idx; char *mmap_cur; u64 file_pos; u64 file_offset; u64 head; u64 size; bool done; struct zstd_data zstd_data; struct decomp_data decomp_data;};
static intreader__init(struct reader *rd, bool *one_mmap){ u64 data_size = rd->data_size; char **mmaps = rd->mmaps;
rd->head = rd->data_offset; data_size += rd->data_offset;
rd->mmap_size = MMAP_SIZE; if (rd->mmap_size > data_size) { rd->mmap_size = data_size; if (one_mmap) *one_mmap = true; }
memset(mmaps, 0, sizeof(rd->mmaps));
if (zstd_init(&rd->zstd_data, 0)) return -1; rd->decomp_data.zstd_decomp = &rd->zstd_data;
return 0;}
static voidreader__release_decomp(struct reader *rd){ perf_decomp__release_events(rd->decomp_data.decomp); zstd_fini(&rd->zstd_data);}
static intreader__mmap(struct reader *rd, struct perf_session *session){ int mmap_prot, mmap_flags; char *buf, **mmaps = rd->mmaps; u64 page_offset;
/* * Native-endian: MAP_SHARED + PROT_READ — the kernel * guarantees page-level coherence but a concurrent writer * could modify the file between validation and use. This * is a theoretical TOCTOU that affects the entire perf.data * processing pipeline; fixing it would require copying each * event to a private buffer before processing. * * Cross-endian: MAP_PRIVATE + PROT_WRITE — swap handlers * get a copy-on-write snapshot immune to concurrent writes. */ mmap_prot = PROT_READ; mmap_flags = MAP_SHARED;
if (rd->in_place_update) { mmap_prot |= PROT_WRITE; } else if (session->header.needs_swap) { mmap_prot |= PROT_WRITE; mmap_flags = MAP_PRIVATE; }
if (mmaps[rd->mmap_idx]) { munmap(mmaps[rd->mmap_idx], rd->mmap_size); mmaps[rd->mmap_idx] = NULL; }
page_offset = page_size * (rd->head / page_size); rd->file_offset += page_offset; rd->head -= page_offset;
buf = mmap(NULL, rd->mmap_size, mmap_prot, mmap_flags, rd->fd, rd->file_offset); if (buf == MAP_FAILED) { pr_err("failed to mmap file\n"); return -errno; } mmaps[rd->mmap_idx] = rd->mmap_cur = buf; rd->mmap_idx = (rd->mmap_idx + 1) & (ARRAY_SIZE(rd->mmaps) - 1); rd->file_pos = rd->file_offset + rd->head; if (session->one_mmap) { session->one_mmap_addr = buf; session->one_mmap_offset = rd->file_offset; /* * mmap_size was set to the full file extent (data_offset + * data_size) but file_offset was shifted forward by * page_offset for page alignment. Reduce by page_offset * so the bounds check reflects the file-backed portion * of the mapping — pages beyond the file cause SIGBUS. */ session->one_mmap_size = rd->mmap_size - page_offset; }
return 0;}
enum { READER_OK, READER_NODATA,};
static intreader__read_event(struct reader *rd, struct perf_session *session, struct ui_progress *prog){ u64 size; int err = READER_OK; union perf_event *event; s64 skip;
event = fetch_mmaped_event(rd->head, rd->mmap_size, rd->mmap_cur, session->header.needs_swap); if (IS_ERR(event)) return PTR_ERR(event);
if (!event) return READER_NODATA;
size = event->header.size;
skip = -EINVAL;
if (size < sizeof(struct perf_event_header) || (skip = rd->process(session, event, rd->file_pos, rd->path)) < 0) { errno = -skip; pr_err("%#" PRIx64 " [%#x]: processing failed for event of type: %s (%d) [%m]\n", rd->file_offset + rd->head, event->header.size, perf_event__name(event->header.type), event->header.type); err = skip; goto out; }
if (skip) size += skip;
rd->size += size; rd->head += size; rd->file_pos += size;
err = __perf_session__process_decomp_events(session); if (err) goto out;
ui_progress__update(prog, size);
out: return err;}
static inline boolreader__eof(struct reader *rd){ return (rd->file_pos >= rd->data_size + rd->data_offset);}
static intreader__process_events(struct reader *rd, struct perf_session *session, struct ui_progress *prog){ int err;
err = reader__init(rd, &session->one_mmap); if (err) goto out;
session->active_decomp = &rd->decomp_data;
remap: err = reader__mmap(rd, session); if (err) goto out;
more: err = reader__read_event(rd, session, prog); if (err < 0) goto out; else if (err == READER_NODATA) goto remap;
if (session_done()) goto out;
if (!reader__eof(rd)) goto more;
out: session->active_decomp = &session->decomp_data; return err;}
static s64 process_simple(struct perf_session *session, union perf_event *event, u64 file_offset, const char *file_path){ return perf_session__process_event(session, event, file_offset, file_path);}
static int __perf_session__process_events(struct perf_session *session){ struct reader rd = { .fd = perf_data__fd(session->data), .path = session->data->file.path, .data_size = session->header.data_size, .data_offset = session->header.data_offset, .process = process_simple, .in_place_update = session->data->in_place_update, }; struct ordered_events *oe = &session->ordered_events; const struct perf_tool *tool = session->tool; struct ui_progress prog; int err;
if (rd.data_size == 0) return -1;
ui_progress__init_size(&prog, rd.data_size, "Processing events...");
err = reader__process_events(&rd, session, &prog); if (err) goto out_err; /* do the final flush for ordered samples */ err = ordered_events__flush(oe, OE_FLUSH__FINAL); if (err) goto out_err; err = auxtrace__flush_events(session, tool); if (err) goto out_err; err = session__flush_deferred_samples(session, tool); if (err) goto out_err; err = perf_session__flush_thread_stacks(session);out_err: ui_progress__finish(); if (!tool->no_warn) perf_session__warn_about_errors(session); /* * We may switching perf.data output, make ordered_events * reusable. */ ordered_events__reinit(&session->ordered_events); auxtrace__free_events(session); reader__release_decomp(&rd); session->one_mmap = false; return err;}
/* * Processing 2 MB of data from each reader in sequence, * because that's the way the ordered events sorting works * most efficiently. */#define READER_MAX_SIZE (2 * 1024 * 1024)
/* * This function reads, merge and process directory data. * It assumens the version 1 of directory data, where each * data file holds per-cpu data, already sorted by kernel. */static int __perf_session__process_dir_events(struct perf_session *session){ struct perf_data *data = session->data; const struct perf_tool *tool = session->tool; int i, ret, readers, nr_readers; struct ui_progress prog; u64 total_size = perf_data__size(session->data); struct reader *rd;
ui_progress__init_size(&prog, total_size, "Processing events...");
nr_readers = 1; for (i = 0; i < data->dir.nr; i++) { if (data->dir.files[i].size) nr_readers++; }
rd = calloc(nr_readers, sizeof(struct reader)); if (!rd) return -ENOMEM;
rd[0] = (struct reader) { .fd = perf_data__fd(session->data), .path = session->data->file.path, .data_size = session->header.data_size, .data_offset = session->header.data_offset, .process = process_simple, .in_place_update = session->data->in_place_update, }; ret = reader__init(&rd[0], NULL); if (ret) goto out_err; ret = reader__mmap(&rd[0], session); if (ret) goto out_err; readers = 1;
for (i = 0; i < data->dir.nr; i++) { if (!data->dir.files[i].size) continue; rd[readers] = (struct reader) { .fd = perf_data_file__fd(&data->dir.files[i]), .path = data->dir.files[i].path, .data_size = data->dir.files[i].size, .data_offset = 0, .process = process_simple, .in_place_update = session->data->in_place_update, }; ret = reader__init(&rd[readers], NULL); if (ret) goto out_err; ret = reader__mmap(&rd[readers], session); if (ret) goto out_err; readers++; }
i = 0; while (readers) { if (session_done()) break;
if (rd[i].done) { i = (i + 1) % nr_readers; continue; } if (reader__eof(&rd[i])) { rd[i].done = true; readers--; continue; }
session->active_decomp = &rd[i].decomp_data; ret = reader__read_event(&rd[i], session, &prog); if (ret < 0) { goto out_err; } else if (ret == READER_NODATA) { ret = reader__mmap(&rd[i], session); if (ret) goto out_err; }
if (rd[i].size >= READER_MAX_SIZE) { rd[i].size = 0; i = (i + 1) % nr_readers; } }
ret = ordered_events__flush(&session->ordered_events, OE_FLUSH__FINAL); if (ret) goto out_err;
ret = session__flush_deferred_samples(session, tool); if (ret) goto out_err;
ret = perf_session__flush_thread_stacks(session);out_err: ui_progress__finish();
if (!tool->no_warn) perf_session__warn_about_errors(session);
/* * We may switching perf.data output, make ordered_events * reusable. */ ordered_events__reinit(&session->ordered_events);
session->one_mmap = false;
session->active_decomp = &session->decomp_data; for (i = 0; i < nr_readers; i++) reader__release_decomp(&rd[i]); zfree(&rd);
return ret;}
int perf_session__process_events(struct perf_session *session){ if (perf_session__register_idle_thread(session) < 0) return -ENOMEM;
if (perf_data__is_pipe(session->data)) return __perf_session__process_pipe_events(session);
if (perf_data__is_dir(session->data) && session->data->dir.nr) return __perf_session__process_dir_events(session);
return __perf_session__process_events(session);}
bool perf_session__has_traces(struct perf_session *session, const char *msg){ struct evsel *evsel;
evlist__for_each_entry(session->evlist, evsel) { if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) return true; }
pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg); return false;}
bool perf_session__has_switch_events(struct perf_session *session){ struct evsel *evsel;
evlist__for_each_entry(session->evlist, evsel) { if (evsel->core.attr.context_switch) return true; }
return false;}
int map__set_kallsyms_ref_reloc_sym(struct map *map, const char *symbol_name, u64 addr){ char *bracket, *name; struct ref_reloc_sym *ref; struct kmap *kmap;
ref = zalloc(sizeof(struct ref_reloc_sym)); if (ref == NULL) return -ENOMEM;
ref->name = name = strdup(symbol_name); if (ref->name == NULL) { free(ref); return -ENOMEM; }
bracket = strchr(name, ']'); if (bracket) *bracket = '\0';
ref->addr = addr;
kmap = map__kmap(map); if (kmap) kmap->ref_reloc_sym = ref;
return 0;}
size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp){ return machines__fprintf_dsos(&session->machines, fp);}
size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp, bool (skip)(struct dso *dso, int parm), int parm){ return machines__fprintf_dsos_buildid(&session->machines, fp, skip, parm);}
size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp){ size_t ret; const char *msg = "";
if (perf_header__has_feat(&session->header, HEADER_AUXTRACE)) msg = " (excludes AUX area (e.g. instruction trace) decoded / synthesized events)";
ret = fprintf(fp, "\nAggregated stats:%s\n", msg);
ret += events_stats__fprintf(&session->evlist->stats, fp); return ret;}
size_t perf_session__fprintf(struct perf_session *session, FILE *fp){ size_t ret = machine__fprintf(&session->machines.host, fp);
for (struct rb_node *nd = rb_first_cached(&session->machines.guests); nd; nd = rb_next(nd)) { struct machine *pos = rb_entry(nd, struct machine, rb_node);
ret += machine__fprintf(pos, fp); } return ret;}
void perf_session__dump_kmaps(struct perf_session *session){ int save_verbose = verbose;
fflush(stdout); fprintf(stderr, "Kernel and module maps:\n"); verbose = 0; /* Suppress verbose to print a summary only */ maps__fprintf(machine__kernel_maps(&session->machines.host), stderr); verbose = save_verbose;}
struct evsel *perf_session__find_first_evtype(struct perf_session *session, unsigned int type){ struct evsel *pos;
evlist__for_each_entry(session->evlist, pos) { if (pos->core.attr.type == type) return pos; } return NULL;}
int perf_session__cpu_bitmap(struct perf_session *session, const char *cpu_list, unsigned long *cpu_bitmap){ unsigned int i; int err = -1; struct perf_cpu_map *map; int nr_cpus = min(perf_session__env(session)->nr_cpus_avail, MAX_NR_CPUS); struct perf_cpu cpu;
for (i = 0; i < PERF_TYPE_MAX; ++i) { struct evsel *evsel;
evsel = perf_session__find_first_evtype(session, i); if (!evsel) continue;
if (!(evsel->core.attr.sample_type & PERF_SAMPLE_CPU)) { pr_err("File does not contain CPU events. " "Remove -C option to proceed.\n"); return -1; } }
map = perf_cpu_map__new(cpu_list); if (map == NULL) { pr_err("Invalid cpu_list\n"); return -1; }
perf_cpu_map__for_each_cpu(cpu, i, map) { if (cpu.cpu >= nr_cpus) { pr_err("Requested CPU %d too large. " "Consider raising MAX_NR_CPUS\n", cpu.cpu); goto out_delete_map; }
__set_bit(cpu.cpu, cpu_bitmap); }
err = 0;
out_delete_map: perf_cpu_map__put(map); return err;}
void perf_session__fprintf_info(struct perf_session *session, FILE *fp, bool full){ if (session == NULL || fp == NULL) return;
fprintf(fp, "# ========\n"); perf_header__fprintf_info(session, fp, full); fprintf(fp, "# ========\n#\n");}
static int perf_session__register_guest(struct perf_session *session, pid_t machine_pid){ struct machine *machine = machines__findnew(&session->machines, machine_pid); struct thread *thread;
if (!machine) return -ENOMEM;
machine->single_address_space = session->machines.host.single_address_space;
thread = machine__idle_thread(machine); if (!thread) return -ENOMEM; thread__put(thread);
machine->kallsyms_filename = perf_data__guest_kallsyms_name(session->data, machine_pid);
return 0;}
static int perf_session__set_guest_cpu(struct perf_session *session, pid_t pid, pid_t tid, int guest_cpu){ struct machine *machine = &session->machines.host; struct thread *thread = machine__findnew_thread(machine, pid, tid);
if (!thread) return -ENOMEM; thread__set_guest_cpu(thread, guest_cpu); thread__put(thread);
return 0;}
int perf_event__process_id_index(const struct perf_tool *tool __maybe_unused, struct perf_session *session, union perf_event *event){ struct evlist *evlist = session->evlist; struct perf_record_id_index *ie = &event->id_index; size_t sz = ie->header.size - sizeof(*ie); size_t i, nr, max_nr; size_t e1_sz = sizeof(struct id_index_entry); size_t e2_sz = sizeof(struct id_index_entry_2); size_t etot_sz = e1_sz + e2_sz; struct id_index_entry_2 *e2; pid_t last_pid = 0;
max_nr = sz / e1_sz; nr = ie->nr; if (nr > max_nr) { printf("Too big: nr %zu max_nr %zu\n", nr, max_nr); return -EINVAL; }
if (sz >= nr * etot_sz) { max_nr = sz / etot_sz; if (nr > max_nr) { printf("Too big2: nr %zu max_nr %zu\n", nr, max_nr); return -EINVAL; } e2 = (void *)ie + sizeof(*ie) + nr * e1_sz; } else { e2 = NULL; }
if (dump_trace) fprintf(stdout, " nr: %zu\n", nr);
for (i = 0; i < nr; i++, (e2 ? e2++ : 0)) { struct id_index_entry *e = &ie->entries[i]; struct perf_sample_id *sid; int ret;
if (dump_trace) { fprintf(stdout, " ... id: %"PRI_lu64, e->id); fprintf(stdout, " idx: %"PRI_lu64, e->idx); fprintf(stdout, " cpu: %"PRI_ld64, e->cpu); fprintf(stdout, " tid: %"PRI_ld64, e->tid); if (e2) { fprintf(stdout, " machine_pid: %"PRI_ld64, e2->machine_pid); fprintf(stdout, " vcpu: %"PRI_lu64"\n", e2->vcpu); } else { fprintf(stdout, "\n"); } }
sid = evlist__id2sid(evlist, e->id); if (!sid) return -ENOENT;
sid->idx = e->idx; sid->cpu.cpu = e->cpu; sid->tid = e->tid;
if (!e2) continue;
sid->machine_pid = e2->machine_pid; sid->vcpu.cpu = e2->vcpu;
if (!sid->machine_pid) continue;
if (sid->machine_pid != last_pid) { ret = perf_session__register_guest(session, sid->machine_pid); if (ret) return ret; last_pid = sid->machine_pid; perf_guest = true; }
ret = perf_session__set_guest_cpu(session, sid->machine_pid, e->tid, e2->vcpu); if (ret) return ret; } return 0;}
int perf_session__dsos_hit_all(struct perf_session *session){ struct rb_node *nd; int err;
err = machine__hit_all_dsos(&session->machines.host); if (err) return err;
for (nd = rb_first_cached(&session->machines.guests); nd; nd = rb_next(nd)) { struct machine *pos = rb_entry(nd, struct machine, rb_node);
err = machine__hit_all_dsos(pos); if (err) return err; }
return 0;}
struct perf_env *perf_session__env(struct perf_session *session){ return &session->header.env;}
struct perf_session__e_machine_cb_args { uint32_t e_flags; uint16_t e_machine;};
static int perf_session__e_machine_cb(struct thread *thread, void *_args){ struct perf_session__e_machine_cb_args *args = _args;
args->e_machine = thread__e_machine(thread, /*machine=*/NULL, &args->e_flags); return args->e_machine != EM_NONE ? 1 : 0;}
/* * Note, a machine may have mixed 32-bit and 64-bit processes and so mixed * e_machines. Use thread__e_machine when this matters. */uint16_t perf_session__e_machine(struct perf_session *session, uint32_t *e_flags){ struct perf_session__e_machine_cb_args args = { .e_machine = EM_NONE, }; struct perf_env *env;
if (!session) { /* Default to assuming a host machine. */ if (e_flags) *e_flags = EF_HOST;
return EM_HOST; }
/* * Is the env caching an e_machine? If not we want to compute from the * more accurate threads. */ env = perf_session__env(session); if (env && env->e_machine != EM_NONE) return perf_env__e_machine(env, e_flags);
/* * Compute from threads, note this is more accurate than * perf_env__e_machine that falls back on EM_HOST and doesn't consider * mixed 32-bit and 64-bit threads. */ machines__for_each_thread(&session->machines, perf_session__e_machine_cb, &args);
if (args.e_machine != EM_NONE) { if (env) { env->e_machine = args.e_machine; env->e_flags = args.e_flags; } if (e_flags) *e_flags = args.e_flags;
return args.e_machine; }
/* * Couldn't determine from the perf_env or current set of * threads. Potentially use logic that uses the arch string otherwise * default to the host. Don't cache in the perf_env in case later * threads indicate a better ELF machine type. */ return perf_env__e_machine_nocache(env, e_flags);}