Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Masami Hiramatsu | 15446 | 82.12% | 169 | 54.87% |
Wang Nan | 814 | 4.33% | 11 | 3.57% |
Ravi Bangoria | 505 | 2.68% | 9 | 2.92% |
Franck Bui-Huu | 361 | 1.92% | 8 | 2.60% |
Srikar Dronamraju | 273 | 1.45% | 3 | 0.97% |
Arnaldo Carvalho de Melo | 251 | 1.33% | 37 | 12.01% |
Ian Rogers | 233 | 1.24% | 13 | 4.22% |
Krister Johansen | 208 | 1.11% | 2 | 0.65% |
Irina Tirdea | 157 | 0.83% | 2 | 0.65% |
Ingo Molnar | 132 | 0.70% | 3 | 0.97% |
Naveen N. Rao | 82 | 0.44% | 5 | 1.62% |
Namhyung Kim | 64 | 0.34% | 9 | 2.92% |
Leo Yan | 43 | 0.23% | 3 | 0.97% |
David Ahern | 39 | 0.21% | 2 | 0.65% |
Yang Jihong | 30 | 0.16% | 1 | 0.32% |
Sumanth Korikkar | 23 | 0.12% | 1 | 0.32% |
Jiri Olsa | 21 | 0.11% | 3 | 0.97% |
He Kuang | 19 | 0.10% | 5 | 1.62% |
Adrian Hunter | 14 | 0.07% | 2 | 0.65% |
Steven Rostedt | 12 | 0.06% | 2 | 0.65% |
Jianlin Lv | 12 | 0.06% | 1 | 0.32% |
Dima Kogan | 11 | 0.06% | 2 | 0.65% |
Zechuan Chen | 9 | 0.05% | 1 | 0.32% |
Konstantin Khlebnikov | 9 | 0.05% | 1 | 0.32% |
Yanmin Zhang | 8 | 0.04% | 1 | 0.32% |
Christophe Jaillet | 8 | 0.04% | 1 | 0.32% |
Riccardo Mancini | 6 | 0.03% | 1 | 0.32% |
Jin Yao | 4 | 0.02% | 1 | 0.32% |
Andi Kleen | 3 | 0.02% | 1 | 0.32% |
Hari Bathini | 3 | 0.02% | 1 | 0.32% |
Thomas Gleixner | 2 | 0.01% | 1 | 0.32% |
James Clark | 2 | 0.01% | 1 | 0.32% |
Athira Rajeev | 2 | 0.01% | 1 | 0.32% |
Colin Ian King | 1 | 0.01% | 1 | 0.32% |
Hui Wang | 1 | 0.01% | 1 | 0.32% |
Li Bin | 1 | 0.01% | 1 | 0.32% |
Prashanth Nageshappa | 1 | 0.01% | 1 | 0.32% |
Total | 18810 | 308 |
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824
// SPDX-License-Identifier: GPL-2.0-or-later /* * probe-event.c : perf-probe definition to probe_events format converter * * Written by Masami Hiramatsu <mhiramat@redhat.com> */ #include <inttypes.h> #include <sys/utsname.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <errno.h> #include <libgen.h> #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <stdarg.h> #include <limits.h> #include <elf.h> #include "build-id.h" #include "event.h" #include "namespaces.h" #include "strlist.h" #include "strfilter.h" #include "debug.h" #include "dso.h" #include "color.h" #include "map.h" #include "maps.h" #include "mutex.h" #include "symbol.h" #include <api/fs/fs.h> #include "trace-event.h" /* For __maybe_unused */ #include "probe-event.h" #include "probe-finder.h" #include "probe-file.h" #include "session.h" #include "string2.h" #include "strbuf.h" #include "parse-events.h" #include <subcmd/pager.h> #include <linux/ctype.h> #include <linux/zalloc.h> #ifdef HAVE_DEBUGINFOD_SUPPORT #include <elfutils/debuginfod.h> #endif #define PERFPROBE_GROUP "probe" /* Defined in kernel/trace/trace.h */ #define MAX_EVENT_NAME_LEN 64 bool probe_event_dry_run; /* Dry run flag */ struct probe_conf probe_conf = { .magic_num = DEFAULT_PROBE_MAGIC_NUM }; static char *synthesize_perf_probe_point(struct perf_probe_point *pp); #define semantic_error(msg ...) pr_err("Semantic error :" msg) int e_snprintf(char *str, size_t size, const char *format, ...) { int ret; va_list ap; va_start(ap, format); ret = vsnprintf(str, size, format, ap); va_end(ap); if (ret >= (int)size) ret = -E2BIG; return ret; } static struct machine *host_machine; /* Initialize symbol maps and path of vmlinux/modules */ int init_probe_symbol_maps(bool user_only) { int ret; symbol_conf.allow_aliases = true; ret = symbol__init(NULL); if (ret < 0) { pr_debug("Failed to init symbol map.\n"); goto out; } if (host_machine || user_only) /* already initialized */ return 0; if (symbol_conf.vmlinux_name) pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name); host_machine = machine__new_host(); if (!host_machine) { pr_debug("machine__new_host() failed.\n"); symbol__exit(); ret = -1; } out: if (ret < 0) pr_warning("Failed to init vmlinux path.\n"); return ret; } void exit_probe_symbol_maps(void) { machine__delete(host_machine); host_machine = NULL; symbol__exit(); } static struct ref_reloc_sym *kernel_get_ref_reloc_sym(struct map **pmap) { struct kmap *kmap; struct map *map = machine__kernel_map(host_machine); if (map__load(map) < 0) return NULL; kmap = map__kmap(map); if (!kmap) return NULL; if (pmap) *pmap = map; return kmap->ref_reloc_sym; } static int kernel_get_symbol_address_by_name(const char *name, u64 *addr, bool reloc, bool reladdr) { struct ref_reloc_sym *reloc_sym; struct symbol *sym; struct map *map; /* ref_reloc_sym is just a label. Need a special fix*/ reloc_sym = kernel_get_ref_reloc_sym(&map); if (reloc_sym && strcmp(name, reloc_sym->name) == 0) *addr = (!map__reloc(map) || reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr; else { sym = machine__find_kernel_symbol_by_name(host_machine, name, &map); if (!sym) return -ENOENT; *addr = map__unmap_ip(map, sym->start) - ((reloc) ? 0 : map__reloc(map)) - ((reladdr) ? map__start(map) : 0); } return 0; } struct kernel_get_module_map_cb_args { const char *module; struct map *result; }; static int kernel_get_module_map_cb(struct map *map, void *data) { struct kernel_get_module_map_cb_args *args = data; struct dso *dso = map__dso(map); const char *short_name = dso__short_name(dso); u16 short_name_len = dso__short_name_len(dso); if (strncmp(short_name + 1, args->module, short_name_len - 2) == 0 && args->module[short_name_len - 2] == '\0') { args->result = map__get(map); return 1; } return 0; } static struct map *kernel_get_module_map(const char *module) { struct kernel_get_module_map_cb_args args = { .module = module, .result = NULL, }; /* A file path -- this is an offline module */ if (module && strchr(module, '/')) return dso__new_map(module); if (!module) { struct map *map = machine__kernel_map(host_machine); return map__get(map); } maps__for_each_map(machine__kernel_maps(host_machine), kernel_get_module_map_cb, &args); return args.result; } struct map *get_target_map(const char *target, struct nsinfo *nsi, bool user) { /* Init maps of given executable or kernel */ if (user) { struct map *map; struct dso *dso; map = dso__new_map(target); dso = map ? map__dso(map) : NULL; if (dso) { mutex_lock(dso__lock(dso)); dso__set_nsinfo(dso, nsinfo__get(nsi)); mutex_unlock(dso__lock(dso)); } return map; } else { return kernel_get_module_map(target); } } static int convert_exec_to_group(const char *exec, char **result) { char *ptr1, *ptr2, *exec_copy; char buf[64]; int ret; exec_copy = strdup(exec); if (!exec_copy) return -ENOMEM; ptr1 = basename(exec_copy); if (!ptr1) { ret = -EINVAL; goto out; } for (ptr2 = ptr1; *ptr2 != '\0'; ptr2++) { if (!isalnum(*ptr2) && *ptr2 != '_') { *ptr2 = '\0'; break; } } ret = e_snprintf(buf, sizeof(buf), "%s_%s", PERFPROBE_GROUP, ptr1); if (ret < 0) goto out; *result = strdup(buf); ret = *result ? 0 : -ENOMEM; out: free(exec_copy); return ret; } static void clear_perf_probe_point(struct perf_probe_point *pp) { zfree(&pp->file); zfree(&pp->function); zfree(&pp->lazy_line); } static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs) { int i; for (i = 0; i < ntevs; i++) clear_probe_trace_event(tevs + i); } static bool kprobe_blacklist__listed(u64 address); static bool kprobe_warn_out_range(const char *symbol, u64 address) { struct map *map; bool ret = false; map = kernel_get_module_map(NULL); if (map) { ret = address <= map__start(map) || map__end(map) < address; if (ret) pr_warning("%s is out of .text, skip it.\n", symbol); map__put(map); } if (!ret && kprobe_blacklist__listed(address)) { pr_warning("%s is blacklisted function, skip it.\n", symbol); ret = true; } return ret; } /* * @module can be module name of module file path. In case of path, * inspect elf and find out what is actual module name. * Caller has to free mod_name after using it. */ static char *find_module_name(const char *module) { int fd; Elf *elf; GElf_Ehdr ehdr; GElf_Shdr shdr; Elf_Data *data; Elf_Scn *sec; char *mod_name = NULL; int name_offset; fd = open(module, O_RDONLY); if (fd < 0) return NULL; elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); if (elf == NULL) goto elf_err; if (gelf_getehdr(elf, &ehdr) == NULL) goto ret_err; sec = elf_section_by_name(elf, &ehdr, &shdr, ".gnu.linkonce.this_module", NULL); if (!sec) goto ret_err; data = elf_getdata(sec, NULL); if (!data || !data->d_buf) goto ret_err; /* * NOTE: * '.gnu.linkonce.this_module' section of kernel module elf directly * maps to 'struct module' from linux/module.h. This section contains * actual module name which will be used by kernel after loading it. * But, we cannot use 'struct module' here since linux/module.h is not * exposed to user-space. Offset of 'name' has remained same from long * time, so hardcoding it here. */ if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) name_offset = 12; else /* expect ELFCLASS64 by default */ name_offset = 24; mod_name = strdup((char *)data->d_buf + name_offset); ret_err: elf_end(elf); elf_err: close(fd); return mod_name; } #ifdef HAVE_LIBDW_SUPPORT static int kernel_get_module_dso(const char *module, struct dso **pdso) { struct dso *dso; struct map *map; const char *vmlinux_name; int ret = 0; if (module) { char module_name[128]; snprintf(module_name, sizeof(module_name), "[%s]", module); map = maps__find_by_name(machine__kernel_maps(host_machine), module_name); if (map) { dso = map__dso(map); map__put(map); goto found; } pr_debug("Failed to find module %s.\n", module); return -ENOENT; } map = machine__kernel_map(host_machine); dso = map__dso(map); if (!dso__has_build_id(dso)) dso__read_running_kernel_build_id(dso, host_machine); vmlinux_name = symbol_conf.vmlinux_name; *dso__load_errno(dso) = 0; if (vmlinux_name) ret = dso__load_vmlinux(dso, map, vmlinux_name, false); else ret = dso__load_vmlinux_path(dso, map); found: *pdso = dso; return ret; } /* * Some binaries like glibc have special symbols which are on the symbol * table, but not in the debuginfo. If we can find the address of the * symbol from map, we can translate the address back to the probe point. */ static int find_alternative_probe_point(struct debuginfo *dinfo, struct perf_probe_point *pp, struct perf_probe_point *result, const char *target, struct nsinfo *nsi, bool uprobes) { struct map *map = NULL; struct symbol *sym; u64 address = 0; int ret = -ENOENT; size_t idx; /* This can work only for function-name based one */ if (!pp->function || pp->file) return -ENOTSUP; map = get_target_map(target, nsi, uprobes); if (!map) return -EINVAL; /* Find the address of given function */ map__for_each_symbol_by_name(map, pp->function, sym, idx) { if (uprobes) { address = sym->start; if (sym->type == STT_GNU_IFUNC) pr_warning("Warning: The probe function (%s) is a GNU indirect function.\n" "Consider identifying the final function used at run time and set the probe directly on that.\n", pp->function); } else address = map__unmap_ip(map, sym->start) - map__reloc(map); break; } if (!address) { ret = -ENOENT; goto out; } pr_debug("Symbol %s address found : %" PRIx64 "\n", pp->function, address); ret = debuginfo__find_probe_point(dinfo, address, result); if (ret <= 0) ret = (!ret) ? -ENOENT : ret; else { result->offset += pp->offset; result->line += pp->line; result->retprobe = pp->retprobe; ret = 0; } out: map__put(map); return ret; } static int get_alternative_probe_event(struct debuginfo *dinfo, struct perf_probe_event *pev, struct perf_probe_point *tmp) { int ret; memcpy(tmp, &pev->point, sizeof(*tmp)); memset(&pev->point, 0, sizeof(pev->point)); ret = find_alternative_probe_point(dinfo, tmp, &pev->point, pev->target, pev->nsi, pev->uprobes); if (ret < 0) memcpy(&pev->point, tmp, sizeof(*tmp)); return ret; } static int get_alternative_line_range(struct debuginfo *dinfo, struct line_range *lr, const char *target, bool user) { struct perf_probe_point pp = { .function = lr->function, .file = lr->file, .line = lr->start }; struct perf_probe_point result; int ret, len = 0; memset(&result, 0, sizeof(result)); if (lr->end != INT_MAX) len = lr->end - lr->start; ret = find_alternative_probe_point(dinfo, &pp, &result, target, NULL, user); if (!ret) { lr->function = result.function; lr->file = result.file; lr->start = result.line; if (lr->end != INT_MAX) lr->end = lr->start + len; clear_perf_probe_point(&pp); } return ret; } #ifdef HAVE_DEBUGINFOD_SUPPORT static struct debuginfo *open_from_debuginfod(struct dso *dso, struct nsinfo *nsi, bool silent) { debuginfod_client *c = debuginfod_begin(); char sbuild_id[SBUILD_ID_SIZE + 1]; struct debuginfo *ret = NULL; struct nscookie nsc; char *path; int fd; if (!c) return NULL; build_id__sprintf(dso__bid(dso), sbuild_id); fd = debuginfod_find_debuginfo(c, (const unsigned char *)sbuild_id, 0, &path); if (fd >= 0) close(fd); debuginfod_end(c); if (fd < 0) { if (!silent) pr_debug("Failed to find debuginfo in debuginfod.\n"); return NULL; } if (!silent) pr_debug("Load debuginfo from debuginfod (%s)\n", path); nsinfo__mountns_enter(nsi, &nsc); ret = debuginfo__new((const char *)path); nsinfo__mountns_exit(&nsc); return ret; } #else static inline struct debuginfo *open_from_debuginfod(struct dso *dso __maybe_unused, struct nsinfo *nsi __maybe_unused, bool silent __maybe_unused) { return NULL; } #endif /* Open new debuginfo of given module */ static struct debuginfo *open_debuginfo(const char *module, struct nsinfo *nsi, bool silent) { const char *path = module; char reason[STRERR_BUFSIZE]; struct debuginfo *ret = NULL; struct dso *dso = NULL; struct nscookie nsc; int err; if (!module || !strchr(module, '/')) { err = kernel_get_module_dso(module, &dso); if (err < 0) { if (!dso || *dso__load_errno(dso) == 0) { if (!str_error_r(-err, reason, STRERR_BUFSIZE)) strcpy(reason, "(unknown)"); } else dso__strerror_load(dso, reason, STRERR_BUFSIZE); if (dso) ret = open_from_debuginfod(dso, nsi, silent); if (ret) return ret; if (!silent) { if (module) pr_err("Module %s is not loaded, please specify its full path name.\n", module); else pr_err("Failed to find the path for the kernel: %s\n", reason); } return NULL; } path = dso__long_name(dso); } nsinfo__mountns_enter(nsi, &nsc); ret = debuginfo__new(path); if (!ret && !silent) { pr_warning("The %s file has no debug information.\n", path); if (!module || !strtailcmp(path, ".ko")) pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, "); else pr_warning("Rebuild with -g, "); pr_warning("or install an appropriate debuginfo package.\n"); } nsinfo__mountns_exit(&nsc); return ret; } /* For caching the last debuginfo */ static struct debuginfo *debuginfo_cache; static char *debuginfo_cache_path; static struct debuginfo *debuginfo_cache__open(const char *module, bool silent) { const char *path = module; /* If the module is NULL, it should be the kernel. */ if (!module) path = "kernel"; if (debuginfo_cache_path && !strcmp(debuginfo_cache_path, path)) goto out; /* Copy module path */ free(debuginfo_cache_path); debuginfo_cache_path = strdup(path); if (!debuginfo_cache_path) { debuginfo__delete(debuginfo_cache); debuginfo_cache = NULL; goto out; } debuginfo_cache = open_debuginfo(module, NULL, silent); if (!debuginfo_cache) zfree(&debuginfo_cache_path); out: return debuginfo_cache; } static void debuginfo_cache__exit(void) { debuginfo__delete(debuginfo_cache); debuginfo_cache = NULL; zfree(&debuginfo_cache_path); } static int get_text_start_address(const char *exec, u64 *address, struct nsinfo *nsi) { Elf *elf; GElf_Ehdr ehdr; GElf_Shdr shdr; int fd, ret = -ENOENT; struct nscookie nsc; nsinfo__mountns_enter(nsi, &nsc); fd = open(exec, O_RDONLY); nsinfo__mountns_exit(&nsc); if (fd < 0) return -errno; elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); if (elf == NULL) { ret = -EINVAL; goto out_close; } if (gelf_getehdr(elf, &ehdr) == NULL) goto out; if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL)) goto out; *address = shdr.sh_addr - shdr.sh_offset; ret = 0; out: elf_end(elf); out_close: close(fd); return ret; } /* * Convert trace point to probe point with debuginfo */ static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp, struct perf_probe_point *pp, bool is_kprobe) { struct debuginfo *dinfo = NULL; u64 stext = 0; u64 addr = tp->address; int ret = -ENOENT; /* convert the address to dwarf address */ if (!is_kprobe) { if (!addr) { ret = -EINVAL; goto error; } ret = get_text_start_address(tp->module, &stext, NULL); if (ret < 0) goto error; addr += stext; } else if (tp->symbol) { /* If the module is given, this returns relative address */ ret = kernel_get_symbol_address_by_name(tp->symbol, &addr, false, !!tp->module); if (ret != 0) goto error; addr += tp->offset; } pr_debug("try to find information at %" PRIx64 " in %s\n", addr, tp->module ? : "kernel"); dinfo = debuginfo_cache__open(tp->module, verbose <= 0); if (dinfo) ret = debuginfo__find_probe_point(dinfo, addr, pp); else ret = -ENOENT; if (ret > 0) { pp->retprobe = tp->retprobe; return 0; } error: pr_debug("Failed to find corresponding probes from debuginfo.\n"); return ret ? : -ENOENT; } /* Adjust symbol name and address */ static int post_process_probe_trace_point(struct probe_trace_point *tp, struct map *map, u64 offs) { struct symbol *sym; u64 addr = tp->address - offs; sym = map__find_symbol(map, addr); if (!sym) { /* * If the address is in the inittext section, map can not * find it. Ignore it if we are probing offline kernel. */ return (symbol_conf.ignore_vmlinux_buildid) ? 0 : -ENOENT; } if (strcmp(sym->name, tp->symbol)) { /* If we have no realname, use symbol for it */ if (!tp->realname) tp->realname = tp->symbol; else free(tp->symbol); tp->symbol = strdup(sym->name); if (!tp->symbol) return -ENOMEM; } tp->offset = addr - sym->start; tp->address -= offs; return 0; } /* * Rename DWARF symbols to ELF symbols -- gcc sometimes optimizes functions * and generate new symbols with suffixes such as .constprop.N or .isra.N * etc. Since those symbols are not recorded in DWARF, we have to find * correct generated symbols from offline ELF binary. * For online kernel or uprobes we don't need this because those are * rebased on _text, or already a section relative address. */ static int post_process_offline_probe_trace_events(struct probe_trace_event *tevs, int ntevs, const char *pathname) { struct map *map; u64 stext = 0; int i, ret = 0; /* Prepare a map for offline binary */ map = dso__new_map(pathname); if (!map || get_text_start_address(pathname, &stext, NULL) < 0) { pr_warning("Failed to get ELF symbols for %s\n", pathname); return -EINVAL; } for (i = 0; i < ntevs; i++) { ret = post_process_probe_trace_point(&tevs[i].point, map, stext); if (ret < 0) break; } map__put(map); return ret; } static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs, int ntevs, const char *exec, struct nsinfo *nsi) { int i, ret = 0; u64 stext = 0; if (!exec) return 0; ret = get_text_start_address(exec, &stext, nsi); if (ret < 0) return ret; for (i = 0; i < ntevs && ret >= 0; i++) { /* point.address is the address of point.symbol + point.offset */ tevs[i].point.address -= stext; tevs[i].point.module = strdup(exec); if (!tevs[i].point.module) { ret = -ENOMEM; break; } tevs[i].uprobes = true; } return ret; } static int post_process_module_probe_trace_events(struct probe_trace_event *tevs, int ntevs, const char *module, struct debuginfo *dinfo) { Dwarf_Addr text_offs = 0; int i, ret = 0; char *mod_name = NULL; struct map *map; if (!module) return 0; map = get_target_map(module, NULL, false); if (!map || debuginfo__get_text_offset(dinfo, &text_offs, true) < 0) { pr_warning("Failed to get ELF symbols for %s\n", module); return -EINVAL; } mod_name = find_module_name(module); for (i = 0; i < ntevs; i++) { ret = post_process_probe_trace_point(&tevs[i].point, map, text_offs); if (ret < 0) break; tevs[i].point.module = strdup(mod_name ? mod_name : module); if (!tevs[i].point.module) { ret = -ENOMEM; break; } } free(mod_name); map__put(map); return ret; } static int post_process_kernel_probe_trace_events(struct probe_trace_event *tevs, int ntevs) { struct ref_reloc_sym *reloc_sym; struct map *map; char *tmp; int i, skipped = 0; /* Skip post process if the target is an offline kernel */ if (symbol_conf.ignore_vmlinux_buildid) return post_process_offline_probe_trace_events(tevs, ntevs, symbol_conf.vmlinux_name); reloc_sym = kernel_get_ref_reloc_sym(&map); if (!reloc_sym) { pr_warning("Relocated base symbol is not found! " "Check /proc/sys/kernel/kptr_restrict\n" "and /proc/sys/kernel/perf_event_paranoid. " "Or run as privileged perf user.\n\n"); return -EINVAL; } for (i = 0; i < ntevs; i++) { if (!tevs[i].point.address) continue; if (tevs[i].point.retprobe && !kretprobe_offset_is_supported()) continue; /* * If we found a wrong one, mark it by NULL symbol. * Since addresses in debuginfo is same as objdump, we need * to convert it to addresses on memory. */ if (kprobe_warn_out_range(tevs[i].point.symbol, map__objdump_2mem(map, tevs[i].point.address))) { tmp = NULL; skipped++; } else { tmp = strdup(reloc_sym->name); if (!tmp) return -ENOMEM; } /* If we have no realname, use symbol for it */ if (!tevs[i].point.realname) tevs[i].point.realname = tevs[i].point.symbol; else free(tevs[i].point.symbol); tevs[i].point.symbol = tmp; tevs[i].point.offset = tevs[i].point.address - (map__reloc(map) ? reloc_sym->unrelocated_addr : reloc_sym->addr); } return skipped; } void __weak arch__post_process_probe_trace_events(struct perf_probe_event *pev __maybe_unused, int ntevs __maybe_unused) { } /* Post processing the probe events */ static int post_process_probe_trace_events(struct perf_probe_event *pev, struct probe_trace_event *tevs, int ntevs, const char *module, bool uprobe, struct debuginfo *dinfo) { int ret; if (uprobe) ret = add_exec_to_probe_trace_events(tevs, ntevs, module, pev->nsi); else if (module) /* Currently ref_reloc_sym based probe is not for drivers */ ret = post_process_module_probe_trace_events(tevs, ntevs, module, dinfo); else ret = post_process_kernel_probe_trace_events(tevs, ntevs); if (ret >= 0) arch__post_process_probe_trace_events(pev, ntevs); return ret; } /* Try to find perf_probe_event with debuginfo */ static int try_to_find_probe_trace_events(struct perf_probe_event *pev, struct probe_trace_event **tevs) { bool need_dwarf = perf_probe_event_need_dwarf(pev); struct perf_probe_point tmp; struct debuginfo *dinfo; int ntevs, ret = 0; /* Workaround for gcc #98776 issue. * Perf failed to add kretprobe event with debuginfo of vmlinux which is * compiled by gcc with -fpatchable-function-entry option enabled. The * same issue with kernel module. The retprobe doesn`t need debuginfo. * This workaround solution use map to query the probe function address * for retprobe event. */ if (pev->point.retprobe) return 0; dinfo = open_debuginfo(pev->target, pev->nsi, !need_dwarf); if (!dinfo) { if (need_dwarf) return -ENODATA; pr_debug("Could not open debuginfo. Try to use symbols.\n"); return 0; } pr_debug("Try to find probe point from debuginfo.\n"); /* Searching trace events corresponding to a probe event */ ntevs = debuginfo__find_trace_events(dinfo, pev, tevs); if (ntevs == 0) { /* Not found, retry with an alternative */ ret = get_alternative_probe_event(dinfo, pev, &tmp); if (!ret) { ntevs = debuginfo__find_trace_events(dinfo, pev, tevs); /* * Write back to the original probe_event for * setting appropriate (user given) event name */ clear_perf_probe_point(&pev->point); memcpy(&pev->point, &tmp, sizeof(tmp)); } } if (ntevs > 0) { /* Succeeded to find trace events */ pr_debug("Found %d probe_trace_events.\n", ntevs); ret = post_process_probe_trace_events(pev, *tevs, ntevs, pev->target, pev->uprobes, dinfo); if (ret < 0 || ret == ntevs) { pr_debug("Post processing failed or all events are skipped. (%d)\n", ret); clear_probe_trace_events(*tevs, ntevs); zfree(tevs); ntevs = 0; } } debuginfo__delete(dinfo); if (ntevs == 0) { /* No error but failed to find probe point. */ char *probe_point = synthesize_perf_probe_point(&pev->point); pr_warning("Probe point '%s' not found.\n", probe_point); free(probe_point); return -ENODEV; } else if (ntevs < 0) { /* Error path : ntevs < 0 */ pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs); if (ntevs == -EBADF) pr_warning("Warning: No dwarf info found in the vmlinux - " "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n"); if (!need_dwarf) { pr_debug("Trying to use symbols.\n"); return 0; } } return ntevs; } #define LINEBUF_SIZE 256 #define NR_ADDITIONAL_LINES 2 static int __show_one_line(FILE *fp, int l, bool skip, bool show_num) { char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE]; const char *color = show_num ? "" : PERF_COLOR_BLUE; const char *prefix = NULL; do { if (fgets(buf, LINEBUF_SIZE, fp) == NULL) goto error; if (skip) continue; if (!prefix) { prefix = show_num ? "%7d " : " "; color_fprintf(stdout, color, prefix, l); } color_fprintf(stdout, color, "%s", buf); } while (strchr(buf, '\n') == NULL); return 1; error: if (ferror(fp)) { pr_warning("File read error: %s\n", str_error_r(errno, sbuf, sizeof(sbuf))); return -1; } return 0; } static int _show_one_line(FILE *fp, int l, bool skip, bool show_num) { int rv = __show_one_line(fp, l, skip, show_num); if (rv == 0) { pr_warning("Source file is shorter than expected.\n"); rv = -1; } return rv; } static int sprint_line_description(char *sbuf, size_t size, struct line_range *lr) { if (!lr->function) return snprintf(sbuf, size, "file: %s, line: %d", lr->file, lr->start); if (lr->file) return snprintf(sbuf, size, "function: %s, file:%s, line: %d", lr->function, lr->file, lr->start); return snprintf(sbuf, size, "function: %s, line:%d", lr->function, lr->start); } #define show_one_line_with_num(f,l) _show_one_line(f,l,false,true) #define show_one_line(f,l) _show_one_line(f,l,false,false) #define skip_one_line(f,l) _show_one_line(f,l,true,false) #define show_one_line_or_eof(f,l) __show_one_line(f,l,false,false) /* * Show line-range always requires debuginfo to find source file and * line number. */ static int __show_line_range(struct line_range *lr, const char *module, bool user) { struct build_id bid; int l = 1; struct int_node *ln; struct debuginfo *dinfo; FILE *fp; int ret; char *tmp; char sbuf[STRERR_BUFSIZE]; char sbuild_id[SBUILD_ID_SIZE] = ""; /* Search a line range */ dinfo = open_debuginfo(module, NULL, false); if (!dinfo) return -ENOENT; ret = debuginfo__find_line_range(dinfo, lr); if (!ret) { /* Not found, retry with an alternative */ pr_debug2("Failed to find line range in debuginfo. Fallback to alternative\n"); ret = get_alternative_line_range(dinfo, lr, module, user); if (!ret) ret = debuginfo__find_line_range(dinfo, lr); else /* Ignore error, we just failed to find it. */ ret = -ENOENT; } if (dinfo->build_id) { build_id__init(&bid, dinfo->build_id, BUILD_ID_SIZE); build_id__sprintf(&bid, sbuild_id); } debuginfo__delete(dinfo); if (ret == 0 || ret == -ENOENT) { sprint_line_description(sbuf, sizeof(sbuf), lr); pr_warning("Specified source line(%s) is not found.\n", sbuf); return -ENOENT; } else if (ret < 0) { pr_warning("Debuginfo analysis failed.\n"); return ret; } /* Convert source file path */ tmp = lr->path; ret = find_source_path(tmp, sbuild_id, lr->comp_dir, &lr->path); /* Free old path when new path is assigned */ if (tmp != lr->path) free(tmp); if (ret < 0) { pr_warning("Failed to find source file path.\n"); return ret; } setup_pager(); if (lr->function) fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path, lr->start - lr->offset); else fprintf(stdout, "<%s:%d>\n", lr->path, lr->start); fp = fopen(lr->path, "r"); if (fp == NULL) { pr_warning("Failed to open %s: %s\n", lr->path, str_error_r(errno, sbuf, sizeof(sbuf))); return -errno; } /* Skip to starting line number */ while (l < lr->start) { ret = skip_one_line(fp, l++); if (ret < 0) goto end; } intlist__for_each_entry(ln, lr->line_list) { for (; ln->i > (unsigned long)l; l++) { ret = show_one_line(fp, l - lr->offset); if (ret < 0) goto end; } ret = show_one_line_with_num(fp, l++ - lr->offset); if (ret < 0) goto end; } if (lr->end == INT_MAX) lr->end = l + NR_ADDITIONAL_LINES; while (l <= lr->end) { ret = show_one_line_or_eof(fp, l++ - lr->offset); if (ret <= 0) break; } end: fclose(fp); return ret; } int show_line_range(struct line_range *lr, const char *module, struct nsinfo *nsi, bool user) { int ret; struct nscookie nsc; ret = init_probe_symbol_maps(user); if (ret < 0) return ret; nsinfo__mountns_enter(nsi, &nsc); ret = __show_line_range(lr, module, user); nsinfo__mountns_exit(&nsc); exit_probe_symbol_maps(); return ret; } static int show_available_vars_at(struct debuginfo *dinfo, struct perf_probe_event *pev, struct strfilter *_filter) { char *buf; int ret, i, nvars; struct str_node *node; struct variable_list *vls = NULL, *vl; struct perf_probe_point tmp; const char *var; buf = synthesize_perf_probe_point(&pev->point); if (!buf) return -EINVAL; pr_debug("Searching variables at %s\n", buf); ret = debuginfo__find_available_vars_at(dinfo, pev, &vls); if (!ret) { /* Not found, retry with an alternative */ ret = get_alternative_probe_event(dinfo, pev, &tmp); if (!ret) { ret = debuginfo__find_available_vars_at(dinfo, pev, &vls); /* Release the old probe_point */ clear_perf_probe_point(&tmp); } } if (ret <= 0) { if (ret == 0 || ret == -ENOENT) { pr_err("Failed to find the address of %s\n", buf); ret = -ENOENT; } else pr_warning("Debuginfo analysis failed.\n"); goto end; } /* Some variables are found */ fprintf(stdout, "Available variables at %s\n", buf); for (i = 0; i < ret; i++) { vl = &vls[i]; /* * A probe point might be converted to * several trace points. */ fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol, vl->point.offset); zfree(&vl->point.symbol); nvars = 0; if (vl->vars) { strlist__for_each_entry(node, vl->vars) { var = strchr(node->s, '\t') + 1; if (strfilter__compare(_filter, var)) { fprintf(stdout, "\t\t%s\n", node->s); nvars++; } } strlist__delete(vl->vars); } if (nvars == 0) fprintf(stdout, "\t\t(No matched variables)\n"); } free(vls); end: free(buf); return ret; } /* Show available variables on given probe point */ int show_available_vars(struct perf_probe_event *pevs, int npevs, struct strfilter *_filter) { int i, ret = 0; struct debuginfo *dinfo; ret = init_probe_symbol_maps(pevs->uprobes); if (ret < 0) return ret; dinfo = open_debuginfo(pevs->target, pevs->nsi, false); if (!dinfo) { ret = -ENOENT; goto out; } setup_pager(); for (i = 0; i < npevs && ret >= 0; i++) ret = show_available_vars_at(dinfo, &pevs[i], _filter); debuginfo__delete(dinfo); out: exit_probe_symbol_maps(); return ret; } #else /* !HAVE_LIBDW_SUPPORT */ static void debuginfo_cache__exit(void) { } static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused, struct perf_probe_point *pp __maybe_unused, bool is_kprobe __maybe_unused) { return -ENOSYS; } static int try_to_find_probe_trace_events(struct perf_probe_event *pev, struct probe_trace_event **tevs __maybe_unused) { if (perf_probe_event_need_dwarf(pev)) { pr_warning("Debuginfo-analysis is not supported.\n"); return -ENOSYS; } return 0; } int show_line_range(struct line_range *lr __maybe_unused, const char *module __maybe_unused, struct nsinfo *nsi __maybe_unused, bool user __maybe_unused) { pr_warning("Debuginfo-analysis is not supported.\n"); return -ENOSYS; } int show_available_vars(struct perf_probe_event *pevs __maybe_unused, int npevs __maybe_unused, struct strfilter *filter __maybe_unused) { pr_warning("Debuginfo-analysis is not supported.\n"); return -ENOSYS; } #endif void line_range__clear(struct line_range *lr) { zfree(&lr->function); zfree(&lr->file); zfree(&lr->path); zfree(&lr->comp_dir); intlist__delete(lr->line_list); } int line_range__init(struct line_range *lr) { memset(lr, 0, sizeof(*lr)); lr->line_list = intlist__new(NULL); if (!lr->line_list) return -ENOMEM; else return 0; } static int parse_line_num(char **ptr, int *val, const char *what) { const char *start = *ptr; errno = 0; *val = strtol(*ptr, ptr, 0); if (errno || *ptr == start) { semantic_error("'%s' is not a valid number.\n", what); return -EINVAL; } return 0; } /* Check the name is good for event, group or function */ static bool is_c_func_name(const char *name) { if (!isalpha(*name) && *name != '_') return false; while (*++name != '\0') { if (!isalpha(*name) && !isdigit(*name) && *name != '_') return false; } return true; } /* * Stuff 'lr' according to the line range described by 'arg'. * The line range syntax is described by: * * SRC[:SLN[+NUM|-ELN]] * FNC[@SRC][:SLN[+NUM|-ELN]] * * FNC@SRC accepts `FNC@*` which forcibly specify FNC as function name. * SRC and FUNC can be quoted by double/single quotes. */ int parse_line_range_desc(const char *arg, struct line_range *lr) { char *buf = strdup(arg); char *p; int err = 0; if (!buf) return -ENOMEM; lr->start = 0; lr->end = INT_MAX; p = strpbrk_esq(buf, ":"); if (p) { if (p == buf) { semantic_error("No file/function name in '%s'.\n", p); err = -EINVAL; goto err; } *(p++) = '\0'; err = parse_line_num(&p, &lr->start, "start line"); if (err) goto err; if (*p == '+' || *p == '-') { const char c = *(p++); err = parse_line_num(&p, &lr->end, "end line"); if (err) goto err; if (c == '+') { lr->end += lr->start; /* * Adjust the number of lines here. * If the number of lines == 1, the * end of line should be equal to * the start of line. */ lr->end--; } } pr_debug("Line range is %d to %d\n", lr->start, lr->end); err = -EINVAL; if (lr->start > lr->end) { semantic_error("Start line must be smaller" " than end line.\n"); goto err; } if (*p != '\0') { semantic_error("Tailing with invalid str '%s'.\n", p); goto err; } } p = strpbrk_esq(buf, "@"); if (p) { *p++ = '\0'; if (strcmp(p, "*")) { lr->file = strdup_esq(p); if (lr->file == NULL) { err = -ENOMEM; goto err; } } if (*buf != '\0') lr->function = strdup_esq(buf); if (!lr->function && !lr->file) { semantic_error("Only '@*' is not allowed.\n"); err = -EINVAL; goto err; } } else if (strpbrk_esq(buf, "/.")) lr->file = strdup_esq(buf); else if (is_c_func_name(buf))/* We reuse it for checking funcname */ lr->function = strdup_esq(buf); else { /* Invalid name */ semantic_error("'%s' is not a valid function name.\n", buf); err = -EINVAL; goto err; } err: free(buf); return err; } static int parse_perf_probe_event_name(char **arg, struct perf_probe_event *pev) { char *ptr; ptr = strpbrk_esq(*arg, ":"); if (ptr) { *ptr = '\0'; if (!pev->sdt && !is_c_func_name(*arg)) goto ng_name; pev->group = strdup_esq(*arg); if (!pev->group) return -ENOMEM; *arg = ptr + 1; } else pev->group = NULL; pev->event = strdup_esq(*arg); if (pev->event == NULL) return -ENOMEM; if (!pev->sdt && !is_c_func_name(pev->event)) { zfree(&pev->event); ng_name: zfree(&pev->group); semantic_error("%s is bad for event name -it must " "follow C symbol-naming rule.\n", *arg); return -EINVAL; } return 0; } /* Parse probepoint definition. */ static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev) { struct perf_probe_point *pp = &pev->point; char *ptr, *tmp; char c, nc = 0; bool file_spec = false; int ret; /* * <Syntax> * perf probe [GRP:][EVENT=]SRC[:LN|;PTN] * perf probe [GRP:][EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT] * perf probe %[GRP:]SDT_EVENT */ if (!arg) return -EINVAL; if (is_sdt_event(arg)) { pev->sdt = true; if (arg[0] == '%') arg++; } ptr = strpbrk_esq(arg, ";=@+%"); if (pev->sdt) { if (ptr) { if (*ptr != '@') { semantic_error("%s must be an SDT name.\n", arg); return -EINVAL; } /* This must be a target file name or build id */ tmp = build_id_cache__complement(ptr + 1); if (tmp) { pev->target = build_id_cache__origname(tmp); free(tmp); } else pev->target = strdup_esq(ptr + 1); if (!pev->target) return -ENOMEM; *ptr = '\0'; } ret = parse_perf_probe_event_name(&arg, pev); if (ret == 0) { if (asprintf(&pev->point.function, "%%%s", pev->event) < 0) ret = -errno; } return ret; } if (ptr && *ptr == '=') { /* Event name */ *ptr = '\0'; tmp = ptr + 1; ret = parse_perf_probe_event_name(&arg, pev); if (ret < 0) return ret; arg = tmp; } /* * Check arg is function or file name and copy it. * * We consider arg to be a file spec if and only if it satisfies * all of the below criteria:: * - it does not include any of "+@%", * - it includes one of ":;", and * - it has a period '.' in the name. * * Otherwise, we consider arg to be a function specification. */ if (!strpbrk_esc(arg, "+@%")) { ptr = strpbrk_esc(arg, ";:"); /* This is a file spec if it includes a '.' before ; or : */ if (ptr && memchr(arg, '.', ptr - arg)) file_spec = true; } ptr = strpbrk_esq(arg, ";:+@%"); if (ptr) { nc = *ptr; *ptr++ = '\0'; } if (arg[0] == '\0') tmp = NULL; else { tmp = strdup_esq(arg); if (tmp == NULL) return -ENOMEM; } if (file_spec) pp->file = tmp; else { pp->function = tmp; /* * Keep pp->function even if this is absolute address, * so it can mark whether abs_address is valid. * Which make 'perf probe lib.bin 0x0' possible. * * Note that checking length of tmp is not needed * because when we access tmp[1] we know tmp[0] is '0', * so tmp[1] should always valid (but could be '\0'). */ if (tmp && !strncmp(tmp, "0x", 2)) { pp->abs_address = strtoull(pp->function, &tmp, 0); if (*tmp != '\0') { semantic_error("Invalid absolute address.\n"); return -EINVAL; } } } /* Parse other options */ while (ptr) { arg = ptr; c = nc; if (c == ';') { /* Lazy pattern must be the last part */ pp->lazy_line = strdup(arg); /* let leave escapes */ if (pp->lazy_line == NULL) return -ENOMEM; break; } ptr = strpbrk_esq(arg, ";:+@%"); if (ptr) { nc = *ptr; *ptr++ = '\0'; } switch (c) { case ':': /* Line number */ pp->line = strtoul(arg, &tmp, 0); if (*tmp != '\0') { semantic_error("There is non-digit char" " in line number.\n"); return -EINVAL; } break; case '+': /* Byte offset from a symbol */ pp->offset = strtoul(arg, &tmp, 0); if (*tmp != '\0') { semantic_error("There is non-digit character" " in offset.\n"); return -EINVAL; } break; case '@': /* File name */ if (pp->file) { semantic_error("SRC@SRC is not allowed.\n"); return -EINVAL; } if (!strcmp(arg, "*")) break; pp->file = strdup_esq(arg); if (pp->file == NULL) return -ENOMEM; break; case '%': /* Probe places */ if (strcmp(arg, "return") == 0) { pp->retprobe = 1; } else { /* Others not supported yet */ semantic_error("%%%s is not supported.\n", arg); return -ENOTSUP; } break; default: /* Buggy case */ pr_err("This program has a bug at %s:%d.\n", __FILE__, __LINE__); return -ENOTSUP; break; } } /* Exclusion check */ if (pp->lazy_line && pp->line) { semantic_error("Lazy pattern can't be used with" " line number.\n"); return -EINVAL; } if (pp->lazy_line && pp->offset) { semantic_error("Lazy pattern can't be used with offset.\n"); return -EINVAL; } if (pp->line && pp->offset) { semantic_error("Offset can't be used with line number.\n"); return -EINVAL; } if (!pp->line && !pp->lazy_line && pp->file && !pp->function) { semantic_error("File always requires line number or " "lazy pattern.\n"); return -EINVAL; } if (pp->offset && !pp->function) { semantic_error("Offset requires an entry function.\n"); return -EINVAL; } if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) { semantic_error("Offset/Line/Lazy pattern can't be used with " "return probe.\n"); return -EINVAL; } pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n", pp->function, pp->file, pp->line, pp->offset, pp->retprobe, pp->lazy_line); return 0; } /* Parse perf-probe event argument */ static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg) { char *tmp, *goodname; struct perf_probe_arg_field **fieldp; pr_debug("parsing arg: %s into ", str); tmp = strchr(str, '='); if (tmp) { arg->name = strndup(str, tmp - str); if (arg->name == NULL) return -ENOMEM; pr_debug("name:%s ", arg->name); str = tmp + 1; } tmp = strchr(str, '@'); if (tmp && tmp != str && !strcmp(tmp + 1, "user")) { /* user attr */ if (!user_access_is_supported()) { semantic_error("ftrace does not support user access\n"); return -EINVAL; } *tmp = '\0'; arg->user_access = true; pr_debug("user_access "); } tmp = strchr(str, ':'); if (tmp) { /* Type setting */ *tmp = '\0'; arg->type = strdup(tmp + 1); if (arg->type == NULL) return -ENOMEM; pr_debug("type:%s ", arg->type); } tmp = strpbrk(str, "-.["); if (!is_c_varname(str) || !tmp) { /* A variable, register, symbol or special value */ arg->var = strdup(str); if (arg->var == NULL) return -ENOMEM; pr_debug("%s\n", arg->var); return 0; } /* Structure fields or array element */ arg->var = strndup(str, tmp - str); if (arg->var == NULL) return -ENOMEM; goodname = arg->var; pr_debug("%s, ", arg->var); fieldp = &arg->field; do { *fieldp = zalloc(sizeof(struct perf_probe_arg_field)); if (*fieldp == NULL) return -ENOMEM; if (*tmp == '[') { /* Array */ str = tmp; (*fieldp)->index = strtol(str + 1, &tmp, 0); (*fieldp)->ref = true; if (*tmp != ']' || tmp == str + 1) { semantic_error("Array index must be a" " number.\n"); return -EINVAL; } tmp++; if (*tmp == '\0') tmp = NULL; } else { /* Structure */ if (*tmp == '.') { str = tmp + 1; (*fieldp)->ref = false; } else if (tmp[1] == '>') { str = tmp + 2; (*fieldp)->ref = true; } else { semantic_error("Argument parse error: %s\n", str); return -EINVAL; } tmp = strpbrk(str, "-.["); } if (tmp) { (*fieldp)->name = strndup(str, tmp - str); if ((*fieldp)->name == NULL) return -ENOMEM; if (*str != '[') goodname = (*fieldp)->name; pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref); fieldp = &(*fieldp)->next; } } while (tmp); (*fieldp)->name = strdup(str); if ((*fieldp)->name == NULL) return -ENOMEM; if (*str != '[') goodname = (*fieldp)->name; pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref); /* If no name is specified, set the last field name (not array index)*/ if (!arg->name) { arg->name = strdup(goodname); if (arg->name == NULL) return -ENOMEM; } return 0; } /* Parse perf-probe event command */ int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev) { char **argv; int argc, i, ret = 0; argv = argv_split(cmd, &argc); if (!argv) { pr_debug("Failed to split arguments.\n"); return -ENOMEM; } if (argc - 1 > MAX_PROBE_ARGS) { semantic_error("Too many probe arguments (%d).\n", argc - 1); ret = -ERANGE; goto out; } /* Parse probe point */ ret = parse_perf_probe_point(argv[0], pev); if (ret < 0) goto out; /* Generate event name if needed */ if (!pev->event && pev->point.function && pev->point.line && !pev->point.lazy_line && !pev->point.offset) { if (asprintf(&pev->event, "%s_L%d", pev->point.function, pev->point.line) < 0) { ret = -ENOMEM; goto out; } } /* Copy arguments and ensure return probe has no C argument */ pev->nargs = argc - 1; pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs); if (pev->args == NULL) { ret = -ENOMEM; goto out; } for (i = 0; i < pev->nargs && ret >= 0; i++) { ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]); if (ret >= 0 && is_c_varname(pev->args[i].var) && pev->point.retprobe) { semantic_error("You can't specify local variable for" " kretprobe.\n"); ret = -EINVAL; } } out: argv_free(argv); return ret; } /* Returns true if *any* ARG is either C variable, $params or $vars. */ bool perf_probe_with_var(struct perf_probe_event *pev) { int i = 0; for (i = 0; i < pev->nargs; i++) if (is_c_varname(pev->args[i].var) || !strcmp(pev->args[i].var, PROBE_ARG_PARAMS) || !strcmp(pev->args[i].var, PROBE_ARG_VARS)) return true; return false; } /* Return true if this perf_probe_event requires debuginfo */ bool perf_probe_event_need_dwarf(struct perf_probe_event *pev) { if (pev->point.file || pev->point.line || pev->point.lazy_line) return true; if (perf_probe_with_var(pev)) return true; return false; } /* Parse probe_events event into struct probe_point */ int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev) { struct probe_trace_point *tp = &tev->point; char pr; char *p; char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str; int ret, i, argc; char **argv; pr_debug("Parsing probe_events: %s\n", cmd); argv = argv_split(cmd, &argc); if (!argv) { pr_debug("Failed to split arguments.\n"); return -ENOMEM; } if (argc < 2) { semantic_error("Too few probe arguments.\n"); ret = -ERANGE; goto out; } /* Scan event and group name. */ argv0_str = strdup(argv[0]); if (argv0_str == NULL) { ret = -ENOMEM; goto out; } fmt1_str = strtok_r(argv0_str, ":", &fmt); fmt2_str = strtok_r(NULL, "/", &fmt); fmt3_str = strtok_r(NULL, " \t", &fmt); if (fmt1_str == NULL || fmt2_str == NULL || fmt3_str == NULL) { semantic_error("Failed to parse event name: %s\n", argv[0]); ret = -EINVAL; goto out; } pr = fmt1_str[0]; tev->group = strdup(fmt2_str); tev->event = strdup(fmt3_str); if (tev->group == NULL || tev->event == NULL) { ret = -ENOMEM; goto out; } pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr); tp->retprobe = (pr == 'r'); /* Scan module name(if there), function name and offset */ p = strchr(argv[1], ':'); if (p) { tp->module = strndup(argv[1], p - argv[1]); if (!tp->module) { ret = -ENOMEM; goto out; } tev->uprobes = (tp->module[0] == '/'); p++; } else p = argv[1]; fmt1_str = strtok_r(p, "+", &fmt); /* only the address started with 0x */ if (fmt1_str[0] == '0') { /* * Fix a special case: * if address == 0, kernel reports something like: * p:probe_libc/abs_0 /lib/libc-2.18.so:0x (null) arg1=%ax * Newer kernel may fix that, but we want to * support old kernel also. */ if (strcmp(fmt1_str, "0x") == 0) { if (!argv[2] || strcmp(argv[2], "(null)")) { ret = -EINVAL; goto out; } tp->address = 0; free(argv[2]); for (i = 2; argv[i + 1] != NULL; i++) argv[i] = argv[i + 1]; argv[i] = NULL; argc -= 1; } else tp->address = strtoull(fmt1_str, NULL, 0); } else { /* Only the symbol-based probe has offset */ tp->symbol = strdup(fmt1_str); if (tp->symbol == NULL) { ret = -ENOMEM; goto out; } fmt2_str = strtok_r(NULL, "", &fmt); if (fmt2_str == NULL) tp->offset = 0; else tp->offset = strtoul(fmt2_str, NULL, 10); } if (tev->uprobes) { fmt2_str = strchr(p, '('); if (fmt2_str) tp->ref_ctr_offset = strtoul(fmt2_str + 1, NULL, 0); } tev->nargs = argc - 2; tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs); if (tev->args == NULL) { ret = -ENOMEM; goto out; } for (i = 0; i < tev->nargs; i++) { p = strchr(argv[i + 2], '='); if (p) /* We don't need which register is assigned. */ *p++ = '\0'; else p = argv[i + 2]; tev->args[i].name = strdup(argv[i + 2]); /* TODO: parse regs and offset */ tev->args[i].value = strdup(p); if (tev->args[i].name == NULL || tev->args[i].value == NULL) { ret = -ENOMEM; goto out; } } ret = 0; out: free(argv0_str); argv_free(argv); return ret; } /* Compose only probe arg */ char *synthesize_perf_probe_arg(struct perf_probe_arg *pa) { struct perf_probe_arg_field *field = pa->field; struct strbuf buf; char *ret = NULL; int err; if (strbuf_init(&buf, 64) < 0) return NULL; if (pa->name && pa->var) err = strbuf_addf(&buf, "%s=%s", pa->name, pa->var); else err = strbuf_addstr(&buf, pa->name ?: pa->var); if (err) goto out; while (field) { if (field->name[0] == '[') err = strbuf_addstr(&buf, field->name); else err = strbuf_addf(&buf, "%s%s", field->ref ? "->" : ".", field->name); field = field->next; if (err) goto out; } if (pa->type) if (strbuf_addf(&buf, ":%s", pa->type) < 0) goto out; ret = strbuf_detach(&buf, NULL); out: strbuf_release(&buf); return ret; } /* Compose only probe point (not argument) */ static char *synthesize_perf_probe_point(struct perf_probe_point *pp) { struct strbuf buf; char *tmp, *ret = NULL; int len, err = 0; if (strbuf_init(&buf, 64) < 0) return NULL; if (pp->function) { if (strbuf_addstr(&buf, pp->function) < 0) goto out; if (pp->offset) err = strbuf_addf(&buf, "+%lu", pp->offset); else if (pp->line) err = strbuf_addf(&buf, ":%d", pp->line); else if (pp->retprobe) err = strbuf_addstr(&buf, "%return"); if (err) goto out; } if (pp->file) { tmp = pp->file; len = strlen(tmp); if (len > 30) { tmp = strchr(pp->file + len - 30, '/'); tmp = tmp ? tmp + 1 : pp->file + len - 30; } err = strbuf_addf(&buf, "@%s", tmp); if (!err && !pp->function && pp->line) err = strbuf_addf(&buf, ":%d", pp->line); } if (!err) ret = strbuf_detach(&buf, NULL); out: strbuf_release(&buf); return ret; } char *synthesize_perf_probe_command(struct perf_probe_event *pev) { struct strbuf buf; char *tmp, *ret = NULL; int i; if (strbuf_init(&buf, 64)) return NULL; if (pev->event) if (strbuf_addf(&buf, "%s:%s=", pev->group ?: PERFPROBE_GROUP, pev->event) < 0) goto out; tmp = synthesize_perf_probe_point(&pev->point); if (!tmp || strbuf_addstr(&buf, tmp) < 0) { free(tmp); goto out; } free(tmp); for (i = 0; i < pev->nargs; i++) { tmp = synthesize_perf_probe_arg(pev->args + i); if (!tmp || strbuf_addf(&buf, " %s", tmp) < 0) { free(tmp); goto out; } free(tmp); } ret = strbuf_detach(&buf, NULL); out: strbuf_release(&buf); return ret; } static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref, struct strbuf *buf, int depth) { int err; if (ref->next) { depth = __synthesize_probe_trace_arg_ref(ref->next, buf, depth + 1); if (depth < 0) return depth; } if (ref->user_access) err = strbuf_addf(buf, "%s%ld(", "+u", ref->offset); else err = strbuf_addf(buf, "%+ld(", ref->offset); return (err < 0) ? err : depth; } static int synthesize_probe_trace_arg(struct probe_trace_arg *arg, struct strbuf *buf) { struct probe_trace_arg_ref *ref = arg->ref; int depth = 0, err; /* Argument name or separator */ if (arg->name) err = strbuf_addf(buf, " %s=", arg->name); else err = strbuf_addch(buf, ' '); if (err) return err; /* Special case: @XXX */ if (arg->value[0] == '@' && arg->ref) ref = ref->next; /* Dereferencing arguments */ if (ref) { depth = __synthesize_probe_trace_arg_ref(ref, buf, 1); if (depth < 0) return depth; } /* Print argument value */ if (arg->value[0] == '@' && arg->ref) err = strbuf_addf(buf, "%s%+ld", arg->value, arg->ref->offset); else err = strbuf_addstr(buf, arg->value); /* Closing */ while (!err && depth--) err = strbuf_addch(buf, ')'); /* Print argument type */ if (!err && arg->type) err = strbuf_addf(buf, ":%s", arg->type); return err; } static int synthesize_probe_trace_args(struct probe_trace_event *tev, struct strbuf *buf) { int i, ret = 0; for (i = 0; i < tev->nargs && ret >= 0; i++) ret = synthesize_probe_trace_arg(&tev->args[i], buf); return ret; } static int synthesize_uprobe_trace_def(struct probe_trace_point *tp, struct strbuf *buf) { int err; /* Uprobes must have tp->module */ if (!tp->module) return -EINVAL; /* * If tp->address == 0, then this point must be a * absolute address uprobe. * try_to_find_absolute_address() should have made * tp->symbol to "0x0". */ if (!tp->address && (!tp->symbol || strcmp(tp->symbol, "0x0"))) return -EINVAL; /* Use the tp->address for uprobes */ err = strbuf_addf(buf, "%s:0x%" PRIx64, tp->module, tp->address); if (err >= 0 && tp->ref_ctr_offset) { if (!uprobe_ref_ctr_is_supported()) return -EINVAL; err = strbuf_addf(buf, "(0x%lx)", tp->ref_ctr_offset); } return err >= 0 ? 0 : err; } static int synthesize_kprobe_trace_def(struct probe_trace_point *tp, struct strbuf *buf) { if (!strncmp(tp->symbol, "0x", 2)) { /* Absolute address. See try_to_find_absolute_address() */ return strbuf_addf(buf, "%s%s0x%" PRIx64, tp->module ?: "", tp->module ? ":" : "", tp->address); } else { return strbuf_addf(buf, "%s%s%s+%lu", tp->module ?: "", tp->module ? ":" : "", tp->symbol, tp->offset); } } char *synthesize_probe_trace_command(struct probe_trace_event *tev) { struct probe_trace_point *tp = &tev->point; struct strbuf buf; char *ret = NULL; int err; if (strbuf_init(&buf, 32) < 0) return NULL; if (strbuf_addf(&buf, "%c:%s/%s ", tp->retprobe ? 'r' : 'p', tev->group, tev->event) < 0) goto error; if (tev->uprobes) err = synthesize_uprobe_trace_def(tp, &buf); else err = synthesize_kprobe_trace_def(tp, &buf); if (err >= 0) err = synthesize_probe_trace_args(tev, &buf); if (err >= 0) ret = strbuf_detach(&buf, NULL); error: strbuf_release(&buf); return ret; } static int find_perf_probe_point_from_map(struct probe_trace_point *tp, struct perf_probe_point *pp, bool is_kprobe) { struct symbol *sym = NULL; struct map *map = NULL; u64 addr = tp->address; int ret = -ENOENT; if (!is_kprobe) { map = dso__new_map(tp->module); if (!map) goto out; sym = map__find_symbol(map, addr); } else { if (tp->symbol && !addr) { if (kernel_get_symbol_address_by_name(tp->symbol, &addr, true, false) < 0) goto out; } if (addr) { addr += tp->offset; sym = machine__find_kernel_symbol(host_machine, addr, &map); } } if (!sym) goto out; pp->retprobe = tp->retprobe; pp->offset = addr - map__unmap_ip(map, sym->start); pp->function = strdup(sym->name); ret = pp->function ? 0 : -ENOMEM; out: map__put(map); return ret; } static int convert_to_perf_probe_point(struct probe_trace_point *tp, struct perf_probe_point *pp, bool is_kprobe) { char buf[128]; int ret; ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe); if (!ret) return 0; ret = find_perf_probe_point_from_map(tp, pp, is_kprobe); if (!ret) return 0; pr_debug("Failed to find probe point from both of dwarf and map.\n"); if (tp->symbol) { pp->function = strdup(tp->symbol); pp->offset = tp->offset; } else { ret = e_snprintf(buf, 128, "0x%" PRIx64, tp->address); if (ret < 0) return ret; pp->function = strdup(buf); pp->offset = 0; } if (pp->function == NULL) return -ENOMEM; pp->retprobe = tp->retprobe; return 0; } static int convert_to_perf_probe_event(struct probe_trace_event *tev, struct perf_probe_event *pev, bool is_kprobe) { struct strbuf buf = STRBUF_INIT; int i, ret; /* Convert event/group name */ pev->event = strdup(tev->event); pev->group = strdup(tev->group); if (pev->event == NULL || pev->group == NULL) return -ENOMEM; /* Convert trace_point to probe_point */ ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe); if (ret < 0) return ret; /* Convert trace_arg to probe_arg */ pev->nargs = tev->nargs; pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs); if (pev->args == NULL) return -ENOMEM; for (i = 0; i < tev->nargs && ret >= 0; i++) { if (tev->args[i].name) pev->args[i].name = strdup(tev->args[i].name); else { if ((ret = strbuf_init(&buf, 32)) < 0) goto error; ret = synthesize_probe_trace_arg(&tev->args[i], &buf); pev->args[i].name = strbuf_detach(&buf, NULL); } if (pev->args[i].name == NULL && ret >= 0) ret = -ENOMEM; } error: if (ret < 0) clear_perf_probe_event(pev); return ret; } void clear_perf_probe_event(struct perf_probe_event *pev) { struct perf_probe_arg_field *field, *next; int i; zfree(&pev->event); zfree(&pev->group); zfree(&pev->target); clear_perf_probe_point(&pev->point); for (i = 0; i < pev->nargs; i++) { zfree(&pev->args[i].name); zfree(&pev->args[i].var); zfree(&pev->args[i].type); field = pev->args[i].field; while (field) { next = field->next; zfree(&field->name); free(field); field = next; } } pev->nargs = 0; zfree(&pev->args); } #define strdup_or_goto(str, label) \ ({ char *__p = NULL; if (str && !(__p = strdup(str))) goto label; __p; }) static int perf_probe_point__copy(struct perf_probe_point *dst, struct perf_probe_point *src) { dst->file = strdup_or_goto(src->file, out_err); dst->function = strdup_or_goto(src->function, out_err); dst->lazy_line = strdup_or_goto(src->lazy_line, out_err); dst->line = src->line; dst->retprobe = src->retprobe; dst->offset = src->offset; return 0; out_err: clear_perf_probe_point(dst); return -ENOMEM; } static int perf_probe_arg__copy(struct perf_probe_arg *dst, struct perf_probe_arg *src) { struct perf_probe_arg_field *field, **ppfield; dst->name = strdup_or_goto(src->name, out_err); dst->var = strdup_or_goto(src->var, out_err); dst->type = strdup_or_goto(src->type, out_err); field = src->field; ppfield = &(dst->field); while (field) { *ppfield = zalloc(sizeof(*field)); if (!*ppfield) goto out_err; (*ppfield)->name = strdup_or_goto(field->name, out_err); (*ppfield)->index = field->index; (*ppfield)->ref = field->ref; field = field->next; ppfield = &((*ppfield)->next); } return 0; out_err: return -ENOMEM; } int perf_probe_event__copy(struct perf_probe_event *dst, struct perf_probe_event *src) { int i; dst->event = strdup_or_goto(src->event, out_err); dst->group = strdup_or_goto(src->group, out_err); dst->target = strdup_or_goto(src->target, out_err); dst->uprobes = src->uprobes; if (perf_probe_point__copy(&dst->point, &src->point) < 0) goto out_err; dst->args = zalloc(sizeof(struct perf_probe_arg) * src->nargs); if (!dst->args) goto out_err; dst->nargs = src->nargs; for (i = 0; i < src->nargs; i++) if (perf_probe_arg__copy(&dst->args[i], &src->args[i]) < 0) goto out_err; return 0; out_err: clear_perf_probe_event(dst); return -ENOMEM; } void clear_probe_trace_event(struct probe_trace_event *tev) { struct probe_trace_arg_ref *ref, *next; int i; zfree(&tev->event); zfree(&tev->group); zfree(&tev->point.symbol); zfree(&tev->point.realname); zfree(&tev->point.module); for (i = 0; i < tev->nargs; i++) { zfree(&tev->args[i].name); zfree(&tev->args[i].value); zfree(&tev->args[i].type); ref = tev->args[i].ref; while (ref) { next = ref->next; free(ref); ref = next; } } zfree(&tev->args); tev->nargs = 0; } struct kprobe_blacklist_node { struct list_head list; u64 start; u64 end; char *symbol; }; static void kprobe_blacklist__delete(struct list_head *blacklist) { struct kprobe_blacklist_node *node; while (!list_empty(blacklist)) { node = list_first_entry(blacklist, struct kprobe_blacklist_node, list); list_del_init(&node->list); zfree(&node->symbol); free(node); } } static int kprobe_blacklist__load(struct list_head *blacklist) { struct kprobe_blacklist_node *node; const char *__debugfs = debugfs__mountpoint(); char buf[PATH_MAX], *p; FILE *fp; int ret; if (__debugfs == NULL) return -ENOTSUP; ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs); if (ret < 0) return ret; fp = fopen(buf, "r"); if (!fp) return -errno; ret = 0; while (fgets(buf, PATH_MAX, fp)) { node = zalloc(sizeof(*node)); if (!node) { ret = -ENOMEM; break; } INIT_LIST_HEAD(&node->list); list_add_tail(&node->list, blacklist); if (sscanf(buf, "0x%" PRIx64 "-0x%" PRIx64, &node->start, &node->end) != 2) { ret = -EINVAL; break; } p = strchr(buf, '\t'); if (p) { p++; if (p[strlen(p) - 1] == '\n') p[strlen(p) - 1] = '\0'; } else p = (char *)"unknown"; node->symbol = strdup(p); if (!node->symbol) { ret = -ENOMEM; break; } pr_debug2("Blacklist: 0x%" PRIx64 "-0x%" PRIx64 ", %s\n", node->start, node->end, node->symbol); ret++; } if (ret < 0) kprobe_blacklist__delete(blacklist); fclose(fp); return ret; } static struct kprobe_blacklist_node * kprobe_blacklist__find_by_address(struct list_head *blacklist, u64 address) { struct kprobe_blacklist_node *node; list_for_each_entry(node, blacklist, list) { if (node->start <= address && address < node->end) return node; } return NULL; } static LIST_HEAD(kprobe_blacklist); static void kprobe_blacklist__init(void) { if (!list_empty(&kprobe_blacklist)) return; if (kprobe_blacklist__load(&kprobe_blacklist) < 0) pr_debug("No kprobe blacklist support, ignored\n"); } static void kprobe_blacklist__release(void) { kprobe_blacklist__delete(&kprobe_blacklist); } static bool kprobe_blacklist__listed(u64 address) { return !!kprobe_blacklist__find_by_address(&kprobe_blacklist, address); } static int perf_probe_event__sprintf(const char *group, const char *event, struct perf_probe_event *pev, const char *module, struct strbuf *result) { int i, ret; char *buf; if (asprintf(&buf, "%s:%s", group, event) < 0) return -errno; ret = strbuf_addf(result, " %-20s (on ", buf); free(buf); if (ret) return ret; /* Synthesize only event probe point */ buf = synthesize_perf_probe_point(&pev->point); if (!buf) return -ENOMEM; ret = strbuf_addstr(result, buf); free(buf); if (!ret && module) ret = strbuf_addf(result, " in %s", module); if (!ret && pev->nargs > 0) { ret = strbuf_add(result, " with", 5); for (i = 0; !ret && i < pev->nargs; i++) { buf = synthesize_perf_probe_arg(&pev->args[i]); if (!buf) return -ENOMEM; ret = strbuf_addf(result, " %s", buf); free(buf); } } if (!ret) ret = strbuf_addch(result, ')'); return ret; } /* Show an event */ int show_perf_probe_event(const char *group, const char *event, struct perf_probe_event *pev, const char *module, bool use_stdout) { struct strbuf buf = STRBUF_INIT; int ret; ret = perf_probe_event__sprintf(group, event, pev, module, &buf); if (ret >= 0) { if (use_stdout) printf("%s\n", buf.buf); else pr_info("%s\n", buf.buf); } strbuf_release(&buf); return ret; } static bool filter_probe_trace_event(struct probe_trace_event *tev, struct strfilter *filter) { char tmp[128]; /* At first, check the event name itself */ if (strfilter__compare(filter, tev->event)) return true; /* Next, check the combination of name and group */ if (e_snprintf(tmp, 128, "%s:%s", tev->group, tev->event) < 0) return false; return strfilter__compare(filter, tmp); } static int __show_perf_probe_events(int fd, bool is_kprobe, struct strfilter *filter) { int ret = 0; struct probe_trace_event tev; struct perf_probe_event pev; struct strlist *rawlist; struct str_node *ent; memset(&tev, 0, sizeof(tev)); memset(&pev, 0, sizeof(pev)); rawlist = probe_file__get_rawlist(fd); if (!rawlist) return -ENOMEM; strlist__for_each_entry(ent, rawlist) { ret = parse_probe_trace_command(ent->s, &tev); if (ret >= 0) { if (!filter_probe_trace_event(&tev, filter)) goto next; ret = convert_to_perf_probe_event(&tev, &pev, is_kprobe); if (ret < 0) goto next; ret = show_perf_probe_event(pev.group, pev.event, &pev, tev.point.module, true); } next: clear_perf_probe_event(&pev); clear_probe_trace_event(&tev); if (ret < 0) break; } strlist__delete(rawlist); /* Cleanup cached debuginfo if needed */ debuginfo_cache__exit(); return ret; } /* List up current perf-probe events */ int show_perf_probe_events(struct strfilter *filter) { int kp_fd, up_fd, ret; setup_pager(); if (probe_conf.cache) return probe_cache__show_all_caches(filter); ret = init_probe_symbol_maps(false); if (ret < 0) return ret; ret = probe_file__open_both(&kp_fd, &up_fd, 0); if (ret < 0) return ret; if (kp_fd >= 0) ret = __show_perf_probe_events(kp_fd, true, filter); if (up_fd >= 0 && ret >= 0) ret = __show_perf_probe_events(up_fd, false, filter); if (kp_fd > 0) close(kp_fd); if (up_fd > 0) close(up_fd); exit_probe_symbol_maps(); return ret; } static int get_new_event_name(char *buf, size_t len, const char *base, struct strlist *namelist, bool ret_event, bool allow_suffix) { int i, ret; char *p, *nbase; if (*base == '.') base++; nbase = strdup(base); if (!nbase) return -ENOMEM; /* Cut off the dot suffixes (e.g. .const, .isra) and version suffixes */ p = strpbrk(nbase, ".@"); if (p && p != nbase) *p = '\0'; /* Try no suffix number */ ret = e_snprintf(buf, len, "%s%s", nbase, ret_event ? "__return" : ""); if (ret < 0) { pr_warning("snprintf() failed: %d; the event name '%s' is too long\n" " Hint: Set a shorter event with syntax \"EVENT=PROBEDEF\"\n" " EVENT: Event name (max length: %d bytes).\n", ret, nbase, MAX_EVENT_NAME_LEN); goto out; } if (!strlist__has_entry(namelist, buf)) goto out; if (!allow_suffix) { pr_warning("Error: event \"%s\" already exists.\n" " Hint: Remove existing event by 'perf probe -d'\n" " or force duplicates by 'perf probe -f'\n" " or set 'force=yes' in BPF source.\n", buf); ret = -EEXIST; goto out; } /* Try to add suffix */ for (i = 1; i < MAX_EVENT_INDEX; i++) { ret = e_snprintf(buf, len, "%s_%d", nbase, i); if (ret < 0) { pr_warning("Add suffix failed: %d; the event name '%s' is too long\n" " Hint: Set a shorter event with syntax \"EVENT=PROBEDEF\"\n" " EVENT: Event name (max length: %d bytes).\n", ret, nbase, MAX_EVENT_NAME_LEN); goto out; } if (!strlist__has_entry(namelist, buf)) break; } if (i == MAX_EVENT_INDEX) { pr_warning("Too many events are on the same function.\n"); ret = -ERANGE; } out: free(nbase); /* Final validation */ if (ret >= 0 && !is_c_func_name(buf)) { pr_warning("Internal error: \"%s\" is an invalid event name.\n", buf); ret = -EINVAL; } return ret; } /* Warn if the current kernel's uprobe implementation is old */ static void warn_uprobe_event_compat(struct probe_trace_event *tev) { int i; char *buf = synthesize_probe_trace_command(tev); struct probe_trace_point *tp = &tev->point; if (tp->ref_ctr_offset && !uprobe_ref_ctr_is_supported()) { pr_warning("A semaphore is associated with %s:%s and " "seems your kernel doesn't support it.\n", tev->group, tev->event); } /* Old uprobe event doesn't support memory dereference */ if (!tev->uprobes || tev->nargs == 0 || !buf) goto out; for (i = 0; i < tev->nargs; i++) { if (strchr(tev->args[i].value, '@')) { pr_warning("%s accesses a variable by symbol name, but that is not supported for user application probe.\n", tev->args[i].value); break; } if (strglobmatch(tev->args[i].value, "[$+-]*")) { pr_warning("Please upgrade your kernel to at least 3.14 to have access to feature %s\n", tev->args[i].value); break; } } out: free(buf); } /* Set new name from original perf_probe_event and namelist */ static int probe_trace_event__set_name(struct probe_trace_event *tev, struct perf_probe_event *pev, struct strlist *namelist, bool allow_suffix) { const char *event, *group; char buf[MAX_EVENT_NAME_LEN]; int ret; /* If probe_event or trace_event already have the name, reuse it */ if (pev->event && !pev->sdt) event = pev->event; else if (tev->event) event = tev->event; else { /* Or generate new one from probe point */ if (pev->point.function && (strncmp(pev->point.function, "0x", 2) != 0) && !strisglob(pev->point.function)) event = pev->point.function; else event = tev->point.realname; } if (pev->group && !pev->sdt) group = pev->group; else if (tev->group) group = tev->group; else group = PERFPROBE_GROUP; if (strlen(group) >= MAX_EVENT_NAME_LEN) { pr_err("Probe group string='%s' is too long (>= %d bytes)\n", group, MAX_EVENT_NAME_LEN); return -ENOMEM; } /* Get an unused new event name */ ret = get_new_event_name(buf, sizeof(buf), event, namelist, tev->point.retprobe, allow_suffix); if (ret < 0) return ret; event = buf; tev->event = strdup(event); tev->group = strdup(group); if (tev->event == NULL || tev->group == NULL) return -ENOMEM; /* * Add new event name to namelist if multiprobe event is NOT * supported, since we have to use new event name for following * probes in that case. */ if (!multiprobe_event_is_supported()) strlist__add(namelist, event); return 0; } static int __open_probe_file_and_namelist(bool uprobe, struct strlist **namelist) { int fd; fd = probe_file__open(PF_FL_RW | (uprobe ? PF_FL_UPROBE : 0)); if (fd < 0) return fd; /* Get current event names */ *namelist = probe_file__get_namelist(fd); if (!(*namelist)) { pr_debug("Failed to get current event list.\n"); close(fd); return -ENOMEM; } return fd; } static int __add_probe_trace_events(struct perf_probe_event *pev, struct probe_trace_event *tevs, int ntevs, bool allow_suffix) { int i, fd[2] = {-1, -1}, up, ret; struct probe_trace_event *tev = NULL; struct probe_cache *cache = NULL; struct strlist *namelist[2] = {NULL, NULL}; struct nscookie nsc; up = pev->uprobes ? 1 : 0; fd[up] = __open_probe_file_and_namelist(up, &namelist[up]); if (fd[up] < 0) return fd[up]; ret = 0; for (i = 0; i < ntevs; i++) { tev = &tevs[i]; up = tev->uprobes ? 1 : 0; if (fd[up] == -1) { /* Open the kprobe/uprobe_events */ fd[up] = __open_probe_file_and_namelist(up, &namelist[up]); if (fd[up] < 0) goto close_out; } /* Skip if the symbol is out of .text or blacklisted */ if (!tev->point.symbol && !pev->uprobes) continue; /* Set new name for tev (and update namelist) */ ret = probe_trace_event__set_name(tev, pev, namelist[up], allow_suffix); if (ret < 0) break; nsinfo__mountns_enter(pev->nsi, &nsc); ret = probe_file__add_event(fd[up], tev); nsinfo__mountns_exit(&nsc); if (ret < 0) break; /* * Probes after the first probe which comes from same * user input are always allowed to add suffix, because * there might be several addresses corresponding to * one code line. */ allow_suffix = true; } if (ret == -EINVAL && pev->uprobes) warn_uprobe_event_compat(tev); if (ret == 0 && probe_conf.cache) { cache = probe_cache__new(pev->target, pev->nsi); if (!cache || probe_cache__add_entry(cache, pev, tevs, ntevs) < 0 || probe_cache__commit(cache) < 0) pr_warning("Failed to add event to probe cache\n"); probe_cache__delete(cache); } close_out: for (up = 0; up < 2; up++) { strlist__delete(namelist[up]); if (fd[up] >= 0) close(fd[up]); } return ret; } static int find_probe_functions(struct map *map, char *name, struct symbol **syms) { int found = 0; struct symbol *sym; struct rb_node *tmp; const char *norm, *ver; char *buf = NULL; bool cut_version = true; if (map__load(map) < 0) return -EACCES; /* Possible permission error to load symbols */ /* If user gives a version, don't cut off the version from symbols */ if (strchr(name, '@')) cut_version = false; map__for_each_symbol(map, sym, tmp) { norm = arch__normalize_symbol_name(sym->name); if (!norm) continue; if (cut_version) { /* We don't care about default symbol or not */ ver = strchr(norm, '@'); if (ver) { buf = strndup(norm, ver - norm); if (!buf) return -ENOMEM; norm = buf; } } if (strglobmatch(norm, name)) { found++; if (syms && found < probe_conf.max_probes) syms[found - 1] = sym; } if (buf) zfree(&buf); } return found; } void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused, struct probe_trace_event *tev __maybe_unused, struct map *map __maybe_unused, struct symbol *sym __maybe_unused) { } static void pr_kallsyms_access_error(void) { pr_err("Please ensure you can read the /proc/kallsyms symbol addresses.\n" "If /proc/sys/kernel/kptr_restrict is '2', you can not read\n" "kernel symbol addresses even if you are a superuser. Please change\n" "it to '1'. If kptr_restrict is '1', the superuser can read the\n" "symbol addresses.\n" "In that case, please run this command again with sudo.\n"); } /* * Find probe function addresses from map. * Return an error or the number of found probe_trace_event */ static int find_probe_trace_events_from_map(struct perf_probe_event *pev, struct probe_trace_event **tevs) { struct map *map = NULL; struct ref_reloc_sym *reloc_sym = NULL; struct symbol *sym; struct symbol **syms = NULL; struct probe_trace_event *tev; struct perf_probe_point *pp = &pev->point; struct probe_trace_point *tp; int num_matched_functions; int ret, i, j, skipped = 0; char *mod_name; map = get_target_map(pev->target, pev->nsi, pev->uprobes); if (!map) { ret = -EINVAL; goto out; } syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes); if (!syms) { ret = -ENOMEM; goto out; } /* * Load matched symbols: Since the different local symbols may have * same name but different addresses, this lists all the symbols. */ num_matched_functions = find_probe_functions(map, pp->function, syms); if (num_matched_functions <= 0) { if (num_matched_functions == -EACCES) { pr_err("Failed to load symbols from %s\n", pev->target ?: "/proc/kallsyms"); if (pev->target) pr_err("Please ensure the file is not stripped.\n"); else pr_kallsyms_access_error(); } else pr_err("Failed to find symbol %s in %s\n", pp->function, pev->target ? : "kernel"); ret = -ENOENT; goto out; } else if (num_matched_functions > probe_conf.max_probes) { pr_err("Too many functions matched in %s\n", pev->target ? : "kernel"); ret = -E2BIG; goto out; } /* Note that the symbols in the kmodule are not relocated */ if (!pev->uprobes && !pev->target && (!pp->retprobe || kretprobe_offset_is_supported())) { reloc_sym = kernel_get_ref_reloc_sym(NULL); if (!reloc_sym) { pr_warning("Relocated base symbol is not found! " "Check /proc/sys/kernel/kptr_restrict\n" "and /proc/sys/kernel/perf_event_paranoid. " "Or run as privileged perf user.\n\n"); ret = -EINVAL; goto out; } } /* Setup result trace-probe-events */ *tevs = zalloc(sizeof(*tev) * num_matched_functions); if (!*tevs) { ret = -ENOMEM; goto out; } ret = 0; for (j = 0; j < num_matched_functions; j++) { sym = syms[j]; if (sym->type != STT_FUNC) continue; /* There can be duplicated symbols in the map */ for (i = 0; i < j; i++) if (sym->start == syms[i]->start) { pr_debug("Found duplicated symbol %s @ %" PRIx64 "\n", sym->name, sym->start); break; } if (i != j) continue; tev = (*tevs) + ret; tp = &tev->point; if (ret == num_matched_functions) { pr_warning("Too many symbols are listed. Skip it.\n"); break; } ret++; if (pp->offset > sym->end - sym->start) { pr_warning("Offset %ld is bigger than the size of %s\n", pp->offset, sym->name); ret = -ENOENT; goto err_out; } /* Add one probe point */ tp->address = map__unmap_ip(map, sym->start) + pp->offset; /* Check the kprobe (not in module) is within .text */ if (!pev->uprobes && !pev->target && kprobe_warn_out_range(sym->name, tp->address)) { tp->symbol = NULL; /* Skip it */ skipped++; } else if (reloc_sym) { tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out); tp->offset = tp->address - reloc_sym->addr; } else { tp->symbol = strdup_or_goto(sym->name, nomem_out); tp->offset = pp->offset; } tp->realname = strdup_or_goto(sym->name, nomem_out); tp->retprobe = pp->retprobe; if (pev->target) { if (pev->uprobes) { tev->point.module = strdup_or_goto(pev->target, nomem_out); } else { mod_name = find_module_name(pev->target); tev->point.module = strdup(mod_name ? mod_name : pev->target); free(mod_name); if (!tev->point.module) goto nomem_out; } } tev->uprobes = pev->uprobes; tev->nargs = pev->nargs; if (tev->nargs) { tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs); if (tev->args == NULL) goto nomem_out; } for (i = 0; i < tev->nargs; i++) { if (pev->args[i].name) tev->args[i].name = strdup_or_goto(pev->args[i].name, nomem_out); tev->args[i].value = strdup_or_goto(pev->args[i].var, nomem_out); if (pev->args[i].type) tev->args[i].type = strdup_or_goto(pev->args[i].type, nomem_out); } arch__fix_tev_from_maps(pev, tev, map, sym); } if (ret == skipped) { ret = -ENOENT; goto err_out; } out: map__put(map); free(syms); return ret; nomem_out: ret = -ENOMEM; err_out: clear_probe_trace_events(*tevs, num_matched_functions); zfree(tevs); goto out; } static int try_to_find_absolute_address(struct perf_probe_event *pev, struct probe_trace_event **tevs) { struct perf_probe_point *pp = &pev->point; struct probe_trace_event *tev; struct probe_trace_point *tp; int i, err; if (!(pev->point.function && !strncmp(pev->point.function, "0x", 2))) return -EINVAL; if (perf_probe_event_need_dwarf(pev)) return -EINVAL; /* * This is 'perf probe /lib/libc.so 0xabcd'. Try to probe at * absolute address. * * Only one tev can be generated by this. */ *tevs = zalloc(sizeof(*tev)); if (!*tevs) return -ENOMEM; tev = *tevs; tp = &tev->point; /* * Don't use tp->offset, use address directly, because * in synthesize_probe_trace_command() address cannot be * zero. */ tp->address = pev->point.abs_address; tp->retprobe = pp->retprobe; tev->uprobes = pev->uprobes; err = -ENOMEM; /* * Give it a '0x' leading symbol name. * In __add_probe_trace_events, a NULL symbol is interpreted as * invalid. */ if (asprintf(&tp->symbol, "0x%" PRIx64, tp->address) < 0) goto errout; /* For kprobe, check range */ if ((!tev->uprobes) && (kprobe_warn_out_range(tev->point.symbol, tev->point.address))) { err = -EACCES; goto errout; } if (asprintf(&tp->realname, "abs_%" PRIx64, tp->address) < 0) goto errout; if (pev->target) { tp->module = strdup(pev->target); if (!tp->module) goto errout; } if (tev->group) { tev->group = strdup(pev->group); if (!tev->group) goto errout; } if (pev->event) { tev->event = strdup(pev->event); if (!tev->event) goto errout; } tev->nargs = pev->nargs; tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs); if (!tev->args) goto errout; for (i = 0; i < tev->nargs; i++) copy_to_probe_trace_arg(&tev->args[i], &pev->args[i]); return 1; errout: clear_probe_trace_events(*tevs, 1); *tevs = NULL; return err; } /* Concatenate two arrays */ static void *memcat(void *a, size_t sz_a, void *b, size_t sz_b) { void *ret; ret = malloc(sz_a + sz_b); if (ret) { memcpy(ret, a, sz_a); memcpy(ret + sz_a, b, sz_b); } return ret; } static int concat_probe_trace_events(struct probe_trace_event **tevs, int *ntevs, struct probe_trace_event **tevs2, int ntevs2) { struct probe_trace_event *new_tevs; int ret = 0; if (*ntevs == 0) { *tevs = *tevs2; *ntevs = ntevs2; *tevs2 = NULL; return 0; } if (*ntevs + ntevs2 > probe_conf.max_probes) ret = -E2BIG; else { /* Concatenate the array of probe_trace_event */ new_tevs = memcat(*tevs, (*ntevs) * sizeof(**tevs), *tevs2, ntevs2 * sizeof(**tevs2)); if (!new_tevs) ret = -ENOMEM; else { free(*tevs); *tevs = new_tevs; *ntevs += ntevs2; } } if (ret < 0) clear_probe_trace_events(*tevs2, ntevs2); zfree(tevs2); return ret; } /* * Try to find probe_trace_event from given probe caches. Return the number * of cached events found, if an error occurs return the error. */ static int find_cached_events(struct perf_probe_event *pev, struct probe_trace_event **tevs, const char *target) { struct probe_cache *cache; struct probe_cache_entry *entry; struct probe_trace_event *tmp_tevs = NULL; int ntevs = 0; int ret = 0; cache = probe_cache__new(target, pev->nsi); /* Return 0 ("not found") if the target has no probe cache. */ if (!cache) return 0; for_each_probe_cache_entry(entry, cache) { /* Skip the cache entry which has no name */ if (!entry->pev.event || !entry->pev.group) continue; if ((!pev->group || strglobmatch(entry->pev.group, pev->group)) && strglobmatch(entry->pev.event, pev->event)) { ret = probe_cache_entry__get_event(entry, &tmp_tevs); if (ret > 0) ret = concat_probe_trace_events(tevs, &ntevs, &tmp_tevs, ret); if (ret < 0) break; } } probe_cache__delete(cache); if (ret < 0) { clear_probe_trace_events(*tevs, ntevs); zfree(tevs); } else { ret = ntevs; if (ntevs > 0 && target && target[0] == '/') pev->uprobes = true; } return ret; } /* Try to find probe_trace_event from all probe caches */ static int find_cached_events_all(struct perf_probe_event *pev, struct probe_trace_event **tevs) { struct probe_trace_event *tmp_tevs = NULL; struct strlist *bidlist; struct str_node *nd; char *pathname; int ntevs = 0; int ret; /* Get the buildid list of all valid caches */ bidlist = build_id_cache__list_all(true); if (!bidlist) { ret = -errno; pr_debug("Failed to get buildids: %d\n", ret); return ret; } ret = 0; strlist__for_each_entry(nd, bidlist) { pathname = build_id_cache__origname(nd->s); ret = find_cached_events(pev, &tmp_tevs, pathname); /* In the case of cnt == 0, we just skip it */ if (ret > 0) ret = concat_probe_trace_events(tevs, &ntevs, &tmp_tevs, ret); free(pathname); if (ret < 0) break; } strlist__delete(bidlist); if (ret < 0) { clear_probe_trace_events(*tevs, ntevs); zfree(tevs); } else ret = ntevs; return ret; } static int find_probe_trace_events_from_cache(struct perf_probe_event *pev, struct probe_trace_event **tevs) { struct probe_cache *cache; struct probe_cache_entry *entry; struct probe_trace_event *tev; struct str_node *node; int ret, i; if (pev->sdt) { /* For SDT/cached events, we use special search functions */ if (!pev->target) return find_cached_events_all(pev, tevs); else return find_cached_events(pev, tevs, pev->target); } cache = probe_cache__new(pev->target, pev->nsi); if (!cache) return 0; entry = probe_cache__find(cache, pev); if (!entry) { /* SDT must be in the cache */ ret = pev->sdt ? -ENOENT : 0; goto out; } ret = strlist__nr_entries(entry->tevlist); if (ret > probe_conf.max_probes) { pr_debug("Too many entries matched in the cache of %s\n", pev->target ? : "kernel"); ret = -E2BIG; goto out; } *tevs = zalloc(ret * sizeof(*tev)); if (!*tevs) { ret = -ENOMEM; goto out; } i = 0; strlist__for_each_entry(node, entry->tevlist) { tev = &(*tevs)[i++]; ret = parse_probe_trace_command(node->s, tev); if (ret < 0) goto out; /* Set the uprobes attribute as same as original */ tev->uprobes = pev->uprobes; } ret = i; out: probe_cache__delete(cache); return ret; } static int convert_to_probe_trace_events(struct perf_probe_event *pev, struct probe_trace_event **tevs) { int ret; if (!pev->group && !pev->sdt) { /* Set group name if not given */ if (!pev->uprobes) { pev->group = strdup(PERFPROBE_GROUP); ret = pev->group ? 0 : -ENOMEM; } else ret = convert_exec_to_group(pev->target, &pev->group); if (ret != 0) { pr_warning("Failed to make a group name.\n"); return ret; } } ret = try_to_find_absolute_address(pev, tevs); if (ret > 0) return ret; /* At first, we need to lookup cache entry */ ret = find_probe_trace_events_from_cache(pev, tevs); if (ret > 0 || pev->sdt) /* SDT can be found only in the cache */ return ret == 0 ? -ENOENT : ret; /* Found in probe cache */ /* Convert perf_probe_event with debuginfo */ ret = try_to_find_probe_trace_events(pev, tevs); if (ret != 0) return ret; /* Found in debuginfo or got an error */ return find_probe_trace_events_from_map(pev, tevs); } int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs) { int i, ret; /* Loop 1: convert all events */ for (i = 0; i < npevs; i++) { /* Init kprobe blacklist if needed */ if (!pevs[i].uprobes) kprobe_blacklist__init(); /* Convert with or without debuginfo */ ret = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs); if (ret < 0) return ret; pevs[i].ntevs = ret; } /* This just release blacklist only if allocated */ kprobe_blacklist__release(); return 0; } static int show_probe_trace_event(struct probe_trace_event *tev) { char *buf = synthesize_probe_trace_command(tev); if (!buf) { pr_debug("Failed to synthesize probe trace event.\n"); return -EINVAL; } /* Showing definition always go stdout */ printf("%s\n", buf); free(buf); return 0; } int show_probe_trace_events(struct perf_probe_event *pevs, int npevs) { struct strlist *namelist = strlist__new(NULL, NULL); struct probe_trace_event *tev; struct perf_probe_event *pev; int i, j, ret = 0; if (!namelist) return -ENOMEM; for (j = 0; j < npevs && !ret; j++) { pev = &pevs[j]; for (i = 0; i < pev->ntevs && !ret; i++) { tev = &pev->tevs[i]; /* Skip if the symbol is out of .text or blacklisted */ if (!tev->point.symbol && !pev->uprobes) continue; /* Set new name for tev (and update namelist) */ ret = probe_trace_event__set_name(tev, pev, namelist, true); if (!ret) ret = show_probe_trace_event(tev); } } strlist__delete(namelist); return ret; } static int show_bootconfig_event(struct probe_trace_event *tev) { struct probe_trace_point *tp = &tev->point; struct strbuf buf; char *ret = NULL; int err; if (strbuf_init(&buf, 32) < 0) return -ENOMEM; err = synthesize_kprobe_trace_def(tp, &buf); if (err >= 0) err = synthesize_probe_trace_args(tev, &buf); if (err >= 0) ret = strbuf_detach(&buf, NULL); strbuf_release(&buf); if (ret) { printf("'%s'", ret); free(ret); } return err; } int show_bootconfig_events(struct perf_probe_event *pevs, int npevs) { struct strlist *namelist = strlist__new(NULL, NULL); struct probe_trace_event *tev; struct perf_probe_event *pev; char *cur_name = NULL; int i, j, ret = 0; if (!namelist) return -ENOMEM; for (j = 0; j < npevs && !ret; j++) { pev = &pevs[j]; if (pev->group && strcmp(pev->group, "probe")) pr_warning("WARN: Group name %s is ignored\n", pev->group); if (pev->uprobes) { pr_warning("ERROR: Bootconfig doesn't support uprobes\n"); ret = -EINVAL; break; } for (i = 0; i < pev->ntevs && !ret; i++) { tev = &pev->tevs[i]; /* Skip if the symbol is out of .text or blacklisted */ if (!tev->point.symbol && !pev->uprobes) continue; /* Set new name for tev (and update namelist) */ ret = probe_trace_event__set_name(tev, pev, namelist, true); if (ret) break; if (!cur_name || strcmp(cur_name, tev->event)) { printf("%sftrace.event.kprobes.%s.probe = ", cur_name ? "\n" : "", tev->event); cur_name = tev->event; } else printf(", "); ret = show_bootconfig_event(tev); } } printf("\n"); strlist__delete(namelist); return ret; } int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs) { int i, ret = 0; /* Loop 2: add all events */ for (i = 0; i < npevs; i++) { ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs, pevs[i].ntevs, probe_conf.force_add); if (ret < 0) break; } return ret; } void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs) { int i, j; struct perf_probe_event *pev; /* Loop 3: cleanup and free trace events */ for (i = 0; i < npevs; i++) { pev = &pevs[i]; for (j = 0; j < pevs[i].ntevs; j++) clear_probe_trace_event(&pevs[i].tevs[j]); zfree(&pevs[i].tevs); pevs[i].ntevs = 0; nsinfo__zput(pev->nsi); clear_perf_probe_event(&pevs[i]); } } int show_available_funcs(const char *target, struct nsinfo *nsi, struct strfilter *_filter, bool user) { struct map *map; struct dso *dso; int ret; ret = init_probe_symbol_maps(user); if (ret < 0) return ret; /* Get a symbol map */ map = get_target_map(target, nsi, user); if (!map) { pr_err("Failed to get a map for %s\n", (target) ? : "kernel"); return -EINVAL; } ret = map__load(map); if (ret) { if (ret == -2) { char *str = strfilter__string(_filter); pr_err("Failed to find symbols matched to \"%s\"\n", str); free(str); } else pr_err("Failed to load symbols in %s\n", (target) ? : "kernel"); goto end; } dso = map__dso(map); dso__sort_by_name(dso); /* Show all (filtered) symbols */ setup_pager(); for (size_t i = 0; i < dso__symbol_names_len(dso); i++) { struct symbol *pos = dso__symbol_names(dso)[i]; if (strfilter__compare(_filter, pos->name)) printf("%s\n", pos->name); } end: map__put(map); exit_probe_symbol_maps(); return ret; } int copy_to_probe_trace_arg(struct probe_trace_arg *tvar, struct perf_probe_arg *pvar) { tvar->value = strdup(pvar->var); if (tvar->value == NULL) return -ENOMEM; if (pvar->type) { tvar->type = strdup(pvar->type); if (tvar->type == NULL) return -ENOMEM; } if (pvar->name) { tvar->name = strdup(pvar->name); if (tvar->name == NULL) return -ENOMEM; } else tvar->name = NULL; return 0; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1