* [PATCH v6 0/7] add support for stapsdt probes
@ 2025-07-28 16:36 Alan Maguire
2025-07-28 16:36 ` [PATCH v6 1/7] usdt: have copy_args() count args while parsing them Alan Maguire
` (6 more replies)
0 siblings, 7 replies; 12+ messages in thread
From: Alan Maguire @ 2025-07-28 16:36 UTC (permalink / raw)
To: dtrace; +Cc: dtrace-devel, Alan Maguire
As well as using dtrace -G to generate USDT probes, programs and
libraries may have added static probes via stapsdt ELF notes.
This series adds support for such probes. Patch 1 prepares for
this support by adding counting to parsing of stapsdt probe args
(since they do not include an explicit arg count); Patch 2 adds
the support, while patches 3-7 add tests covering that support.
Changes since v5:
- update copy_args() to remove strlen() check on every iteration
(Kris, patch 1)
- restrict to specific pid probing, removing wildcard support for
now (Kris, patch 2)
- add support for semaphores for is-enabled like stapsdt probes
(Kris, patch 2)
- add test for semaphore support (patch 7)
Changes since v4:
- fix up address computation to work for libraries and -fPIE
binaries; add a test for the latter (Kris, patches 2,6)
- do mapfile, Paddr_to_map() lookups once for stapsdt probes
(Kris, patch 2)
Changes since v3:
- merged with USDT ELF note changes; since these use the same
argument-parsing/access code, no need to add code for this now (patch 2)
- updated said ELF note parsing to count as well as parse arguments
since stapsdt probes do not provide an arg count (patch 1)
- added explicit stapsdt provider to reflect that stapsdt probes
are fundamentally different and do not auto-register for discovery
via ioctl (patch 2, Kris)
- added simple pid wildcarding support for /proc map parsing.
Changes since v2:
- updated terminology to distinguish stapsdt from USDT probes
Alan Maguire (7):
usdt: have copy_args() count args while parsing them
support stapsdt ELF-note-defined static probes
selftests/usdt: add test for stapsdt note-defined probe firing, args
selftests/usdt: add test for stapsdt notes in shared library
selftests/usdt: add test covering different forms of stapsdt note args
selftests/usdt: add test for stapsdt note-defined probe firing in
-fPIE binary
selftests/usdt: add is-enabled stapsdt tests using semaphores
include/dtrace/pid.h | 2 +
libdtrace/dt_pid.c | 284 ++++++++++
libdtrace/dt_prov_uprobe.c | 72 ++-
test/unittest/usdt/sdt_notes.h | 504 ++++++++++++++++++
test/unittest/usdt/tst.stapsdt-notes-args.r | 2 +
test/unittest/usdt/tst.stapsdt-notes-args.sh | 50 ++
.../usdt/tst.stapsdt-notes-isenabled.r | 14 +
.../usdt/tst.stapsdt-notes-isenabled.sh | 151 ++++++
test/unittest/usdt/tst.stapsdt-notes-lib.r | 14 +
test/unittest/usdt/tst.stapsdt-notes-lib.sh | 145 +++++
test/unittest/usdt/tst.stapsdt-notes-pie.sh | 121 +++++
test/unittest/usdt/tst.stapsdt-notes.r | 14 +
test/unittest/usdt/tst.stapsdt-notes.sh | 121 +++++
13 files changed, 1481 insertions(+), 13 deletions(-)
create mode 100644 test/unittest/usdt/sdt_notes.h
create mode 100644 test/unittest/usdt/tst.stapsdt-notes-args.r
create mode 100755 test/unittest/usdt/tst.stapsdt-notes-args.sh
create mode 100644 test/unittest/usdt/tst.stapsdt-notes-isenabled.r
create mode 100755 test/unittest/usdt/tst.stapsdt-notes-isenabled.sh
create mode 100644 test/unittest/usdt/tst.stapsdt-notes-lib.r
create mode 100755 test/unittest/usdt/tst.stapsdt-notes-lib.sh
create mode 100755 test/unittest/usdt/tst.stapsdt-notes-pie.sh
create mode 100644 test/unittest/usdt/tst.stapsdt-notes.r
create mode 100755 test/unittest/usdt/tst.stapsdt-notes.sh
--
2.39.3
^ permalink raw reply [flat|nested] 12+ messages in thread* [PATCH v6 1/7] usdt: have copy_args() count args while parsing them 2025-07-28 16:36 [PATCH v6 0/7] add support for stapsdt probes Alan Maguire @ 2025-07-28 16:36 ` Alan Maguire 2025-07-28 16:36 ` [PATCH v6 2/7] support stapsdt ELF-note-defined static probes Alan Maguire ` (5 subsequent siblings) 6 siblings, 0 replies; 12+ messages in thread From: Alan Maguire @ 2025-07-28 16:36 UTC (permalink / raw) To: dtrace; +Cc: dtrace-devel, Alan Maguire stapsdt probes do not include an argument count, so the only way to count them is to parse the parameter string. Adjust copy_args() to set upp->sargc while parsing upp->sargv. Signed-off-by: Alan Maguire <alan.maguire@oracle.com> --- libdtrace/dt_prov_uprobe.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/libdtrace/dt_prov_uprobe.c b/libdtrace/dt_prov_uprobe.c index f60bdceb..99b97b75 100644 --- a/libdtrace/dt_prov_uprobe.c +++ b/libdtrace/dt_prov_uprobe.c @@ -1145,9 +1145,9 @@ static void enable_usdt(dtrace_hdl_t *dtp, dt_probe_t *prp) } /* - * Generate code that populates the probe arguments. + * Generate code that populates, counts the probe arguments. */ -static void copy_args(dt_pcb_t *pcb, const dt_uprobe_t *upp) +static void copy_args(dt_pcb_t *pcb, dt_uprobe_t *upp) { dtrace_hdl_t *dtp = pcb->pcb_hdl; dt_irlist_t *dlp = &pcb->pcb_ir; @@ -1158,7 +1158,7 @@ static void copy_args(dt_pcb_t *pcb, const dt_uprobe_t *upp) assert(pvp != NULL); - for (i = 0; i < upp->sargc; i++) { + for (i = 0; *p != '\0'; i++) { int ssize, disp, len; char *reg = NULL; int64_t val = 0; @@ -1425,6 +1425,7 @@ static void copy_args(dt_pcb_t *pcb, const dt_uprobe_t *upp) usdt_error(pcb, "Unknown format in arg%d spec", i); #endif } + upp->sargc = i; } /* @@ -1445,7 +1446,7 @@ static int trampoline(dt_pcb_t *pcb, uint_t exitlbl) dtrace_hdl_t *dtp = pcb->pcb_hdl; dt_irlist_t *dlp = &pcb->pcb_ir; const dt_probe_t *uprp = pcb->pcb_probe; - const dt_uprobe_t *upp = uprp->prv_data; + dt_uprobe_t *upp = uprp->prv_data; const list_probe_t *pop; uint_t lbl_exit = pcb->pcb_exitlbl; dt_ident_t *usdt_prids = dt_dlib_get_map(dtp, "usdt_prids"); @@ -1519,7 +1520,7 @@ static int trampoline(dt_pcb_t *pcb, uint_t exitlbl) if (upp->flags & PP_IS_RETURN) goto out; - if (upp->sargc) + if (upp->sargv) copy_args(pcb, upp); else dt_cg_tramp_copy_args_from_regs(pcb, 0); -- 2.39.3 ^ permalink raw reply related [flat|nested] 12+ messages in thread
* [PATCH v6 2/7] support stapsdt ELF-note-defined static probes 2025-07-28 16:36 [PATCH v6 0/7] add support for stapsdt probes Alan Maguire 2025-07-28 16:36 ` [PATCH v6 1/7] usdt: have copy_args() count args while parsing them Alan Maguire @ 2025-07-28 16:36 ` Alan Maguire 2025-07-28 16:36 ` [PATCH v6 3/7] selftests/usdt: add test for stapsdt note-defined probe firing, args Alan Maguire ` (4 subsequent siblings) 6 siblings, 0 replies; 12+ messages in thread From: Alan Maguire @ 2025-07-28 16:36 UTC (permalink / raw) To: dtrace; +Cc: dtrace-devel, Alan Maguire As well as using dtrace -G to generate USDT probes, programs and libraries may have added static probes via stapsdt ELF notes. Read ELF notes from binaries from /proc/ maps associated with processes and parse them to retrieve uprobe address and argument-related info to create the associated uprobe. Probe arguments can be either constants, register values or dereferences or dereferences from register values (plus offset), identical to the updated USDT ELF note handling. A new provider - stapsdt - implements this support, as stapsdt probes do not dynamically register themselves with DTrace. This makes them less powerful than DTrace-based USDT probes, but they do exist in programs and libraries so should be supported. As well as supporting ELF-note stapsdt defined probes in programs and libraries, this patch supports dynamically-created probes that are created via libstapsdt [1]. libstapsdt allows dynamic languages like python to declare and fire probes by dynamically creating a memfd-based shared library containing ELF notes for the probes. With these changes we can also trace these probes. This is very useful since libstapsdt has python, NodeJS, go and luaJIT bindings. [1] https://github.com/linux-usdt/libstapsdt Signed-off-by: Alan Maguire <alan.maguire@oracle.com> --- include/dtrace/pid.h | 2 + libdtrace/dt_pid.c | 284 +++++++++++++++++++++++++++++++++++++ libdtrace/dt_prov_uprobe.c | 61 ++++++-- 3 files changed, 339 insertions(+), 8 deletions(-) diff --git a/include/dtrace/pid.h b/include/dtrace/pid.h index 8d4b6432..8ddb1167 100644 --- a/include/dtrace/pid.h +++ b/include/dtrace/pid.h @@ -24,6 +24,7 @@ typedef enum pid_probetype { DTPPT_OFFSETS, DTPPT_ABSOFFSETS, DTPPT_USDT, + DTPPT_STAPSDT, DTPPT_IS_ENABLED } pid_probetype_t; @@ -37,6 +38,7 @@ typedef struct pid_probespec { ino_t pps_inum; /* object inode */ char *pps_fn; /* object full filename */ uint64_t pps_off; /* probe offset (in object) */ + uint64_t pps_refcntr_off; /* probe ref counter offset */ int pps_nargc; /* number of native args */ int pps_xargc; /* number of xlated and mapped args */ char *pps_nargv; /* array of native args */ diff --git a/libdtrace/dt_pid.c b/libdtrace/dt_pid.c index d12b7919..a75da53f 100644 --- a/libdtrace/dt_pid.c +++ b/libdtrace/dt_pid.c @@ -38,6 +38,9 @@ #include <dt_pid.h> #include <dt_string.h> +#define SEC_STAPSDT_NOTE ".note.stapsdt" +#define NAME_STAPSDT_NOTE "stapsdt" + /* * Information on a PID probe. */ @@ -1262,6 +1265,284 @@ dt_pid_create_pid_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, dt_pcb_t *p return err; } +static int +dt_stapsdt_parse(dtrace_hdl_t *dtp, dt_proc_t *dpr, dtrace_probedesc_t *pdp, + dt_pcb_t *pcb, const dt_provider_t *pvp, char *path, + unsigned long addr_start) +{ + size_t shstrndx, noff, doff, off, n; + const prmap_t *pmp = NULL; + char *mapfile = NULL; + Elf_Scn *scn = NULL; + Elf *elf = NULL; + GElf_Shdr shdr; + GElf_Ehdr ehdr; + GElf_Nhdr nhdr; + Elf_Data *data; + int i, err = 0; + int fd = -1; + char *mod; + + fd = open(path, O_RDONLY); + if (fd < 0) { + dt_pid_error(dtp, pcb, dpr, D_PROC_USDT, + "Cannot open %s: %s\n", + path, strerror(errno)); + return -1; + } + mod = strrchr(path, '/'); + if (mod) + mod++; + else + mod = path; + + elf = elf_begin(fd, ELF_C_READ_MMAP, NULL); // ELF_C_READ ? + + if (elf_kind(elf) != ELF_K_ELF) + return -1; + elf_getshdrstrndx(elf, &shstrndx); + + if (gelf_getehdr(elf, &ehdr)) { + switch (ehdr.e_type) { + case ET_EXEC: + /* binary does not require base addr adjustment */ + addr_start = 0; + break; + case ET_DYN: + break; + default: + dt_dprintf("unexpected ELF hdr type 0x%x for '%s'\n", + ehdr.e_type, path); + err = -1; + goto out; + } + } + + while ((scn = elf_nextscn(elf, scn)) != NULL) { + char *secname; + + assert(gelf_getshdr(scn, &shdr) != NULL); + + secname = elf_strptr(elf, shstrndx, shdr.sh_name); + if (strcmp(secname, SEC_STAPSDT_NOTE) == 0 && + shdr.sh_type == SHT_NOTE) + break; + } + /* No ELF notes, just bail. */ + if (scn == NULL) + goto out; + data = elf_getdata(scn, 0); + for (off = 0; + (off = gelf_getnote(data, off, &nhdr, &noff, &doff)) > 0;) { + pid_probespec_t psp = {0}; + char *prv, *prb; + const char *fun; + char *dbuf = (char *)data->d_buf; + long *addrs = data->d_buf + doff; /* 3 addrs are loc/base/semaphore */ + GElf_Sym sym; + + if (strncmp(dbuf + noff, NAME_STAPSDT_NOTE, nhdr.n_namesz) != 0) + continue; + prv = dbuf + doff + (3*sizeof(long)); + /* ensure prv/prb is null-terminated */ + if (strlen(prv) >= nhdr.n_descsz) + continue; + prb = prv + strlen(prv) + 1; + if (strlen(prb) >= nhdr.n_descsz) + continue; + if (strncmp(pdp->prv, prv, strlen(prv)) != 0) + continue; + /* skip unmatched, non-wildcarded probes */ + if (strcmp(pdp->prb, "*") != 0 && + (strlen(pdp->prb) > 0 && strcmp(pdp->prb, prb) != 0)) + continue; + if (prb + strlen(prb) + 1 < dbuf + doff + nhdr.n_descsz) + psp.pps_sargv = prb + strlen(prb) + 1; + + psp.pps_type = DTPPT_STAPSDT; + psp.pps_prv = prv; + psp.pps_mod = mod; + psp.pps_prb = prb; + if (elf_getphdrnum(elf, &n)) + continue; + + for (i = 0; i < n; i++) { + GElf_Phdr phdr; + + if (!gelf_getphdr(elf, i, &phdr)) + break; + if (addrs[0] >= phdr.p_vaddr && + addrs[0] < phdr.p_vaddr + phdr.p_memsz) { + psp.pps_off = addrs[0] - phdr.p_vaddr + phdr.p_offset; + } + if (!addrs[2]) + continue; + if (addrs[2] >= phdr.p_vaddr && + addrs[2] < phdr.p_vaddr + phdr.p_memsz) + psp.pps_refcntr_off = addrs[2] - phdr.p_vaddr + phdr.p_offset; + } + + if (!psp.pps_off) + continue; + psp.pps_nameoff = 0; + + if (!pmp) + pmp = Paddr_to_map(dpr->dpr_proc, addr_start + addrs[0]); + if (!pmp) { + dt_dprintf("%i: cannot determine 0x%lx's mapping\n", + Pgetpid(dpr->dpr_proc), psp.pps_off); + continue; + } + if (!mapfile) + mapfile = Pmap_mapfile_name(dpr->dpr_proc, pmp); + + if (!mapfile) { + dt_pid_error(dtp, pcb, dpr, D_PROC_USDT, + "Cannot get name of mapping containing probe %s for pid %d\n", + psp.pps_prb, dpr->dpr_pid); + err = -1; + break; + } + psp.pps_fn = mapfile; + if (dt_Plookup_by_addr(dtp, dpr->dpr_pid, addr_start + addrs[0], + &fun, &sym) == 0) + psp.pps_fun = (char *)fun; + else + psp.pps_fun = ""; + psp.pps_dev = pmp->pr_dev; + psp.pps_inum = pmp->pr_inum; + psp.pps_pid = dpr->dpr_pid; + psp.pps_nameoff = 0; + + if (pvp->impl->provide_probe(dtp, &psp) < 0) { + dt_pid_error(dtp, pcb, dpr, D_PROC_USDT, + "failed to instantiate probe %s for pid %d: %s", + psp.pps_prb, psp.pps_pid, + dtrace_errmsg(dtp, dtrace_errno(dtp))); + err = -1; + } + if (err == -1) + break; + } + +out: + free(mapfile); + elf_end(elf); + close(fd); + return err; +} + +static void +dt_pid_create_stapsdt_probes_proc(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, + dt_pcb_t *pcb, const dt_provider_t *pvp, + dt_proc_t *dpr, const char *proc_map) +{ + char line[1024]; + FILE *fp = NULL; + pid_t pid; + + assert(dpr != NULL); + + pid = dpr->dpr_pid; + fp = fopen(proc_map, "r"); + if (!fp) + return; + + while (fgets(line, sizeof(line) - 1, fp) != NULL) { + long addr_start, addr_end, file_offset; + long dev_major, dev_minor; + unsigned long inode; + char name[PATH_MAX + 1]; + char path[PATH_MAX + 1]; + char perm[5]; + int ret; + + ret = sscanf(line, + "%lx-%lx %4s %lx %lx:%lx %lu %[^\n]", + &addr_start, &addr_end, perm, &file_offset, + &dev_major, &dev_minor, &inode, name); + if (ret != 8 || !strchr(perm, 'x') || strchr(name, '[') != NULL) + continue; + + /* libstapsdt uses an memfd-based library to dynamically create + * stapsdt notes for dynamic languages like python; we need + * the associated /proc/<pid>/fds/ fd to read these notes. + */ + if (strncmp(name, "/memfd:", strlen("/memfd:")) == 0) { + DIR *d; + struct dirent *dirent; + char *deleted; + + deleted = strstr(name, " (deleted)"); + if (deleted) + *deleted = '\0'; + snprintf(path, sizeof(path), "/proc/%d/fd", pid); + d = opendir(path); + if (d == NULL) + continue; + while ((dirent = readdir(d)) != NULL) { + struct stat s; + + snprintf(path, sizeof(path), "/proc/%d/fd/%s", + pid, dirent->d_name); + if (stat(path, &s) != 0 || s.st_ino != inode) + continue; + if (dt_stapsdt_parse(dtp, dpr, pdp, pcb, pvp, + path, addr_start - file_offset) != 0) + break; + } + } else { + if (dt_stapsdt_parse(dtp, dpr, pdp, pcb, pvp, name, + addr_start - file_offset) != 0) + break; + } + } + fclose(fp); +} + +static int +dt_pid_create_stapsdt_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, dt_pcb_t *pcb) +{ + const dt_provider_t *pvp; + dt_proc_t *dpr = NULL; + const char *pidstr; + char *path = NULL; + pid_t pid; + + assert(pcb != NULL); + + pidstr = &pdp->prv[strlen(pdp->prv)]; + + while (isdigit(*(pidstr - 1))) + pidstr--; + if (strlen(pidstr) == 0) + return 0; + + asprintf(&path, "/proc/%s/maps", pidstr); + + pvp = dt_provider_lookup(dtp, "stapsdt"); + assert(pvp != NULL); + + pid = atoll(pidstr); + if (pid <= 0) + return 0; + if (dt_proc_grab_lock(dtp, pid, DTRACE_PROC_WAITING | + DTRACE_PROC_SHORTLIVED) < 0) { + dt_pid_error(dtp, pcb, NULL, D_PROC_GRAB, + "failed to grab process %d", + (int)pid); + return 1; + } + dpr = dt_proc_lookup(dtp, pid); + if (dpr) { + dt_pid_create_stapsdt_probes_proc(pdp, dtp, pcb, + pvp, dpr, path); + dt_proc_release_unlock(dtp, pid); + } + + return 0; +} + int dt_pid_create_usdt_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, dt_pcb_t *pcb) { @@ -1319,6 +1600,9 @@ dt_pid_create_usdt_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, dt_pcb_t * free(globpat); globfree(&globbuf); + if (err == 0) + err = dt_pid_create_stapsdt_probes(pdp, dtp, pcb); + /* If no errors, report success. */ if (err == 0) return 0; diff --git a/libdtrace/dt_prov_uprobe.c b/libdtrace/dt_prov_uprobe.c index 99b97b75..3c269870 100644 --- a/libdtrace/dt_prov_uprobe.c +++ b/libdtrace/dt_prov_uprobe.c @@ -283,6 +283,7 @@ typedef struct dt_uprobe { char *fn; /* object full file name */ char *func; /* function */ uint64_t off; + uint64_t refcntr_off; /* optional reference counter offset */ int flags; tp_probe_t *tp; int argc; /* number of args */ @@ -313,12 +314,15 @@ static const dtrace_pattr_t pattr = { dt_provimpl_t dt_pid; dt_provimpl_t dt_usdt; +dt_provimpl_t dt_stapsdt; static int populate(dtrace_hdl_t *dtp) { if (dt_provider_create(dtp, dt_uprobe.name, &dt_uprobe, &pattr, NULL) == NULL || dt_provider_create(dtp, dt_pid.name, &dt_pid, &pattr, + NULL) == NULL || + dt_provider_create(dtp, dt_stapsdt.name, &dt_stapsdt, &pattr, NULL) == NULL) return -1; /* errno already set */ @@ -477,8 +481,8 @@ clean_usdt_probes(dtrace_hdl_t *dtp) prp_next = dt_list_next(prp); - /* Make sure it is an overlying USDT probe. */ - if (prp->prov->impl != &dt_usdt) + /* Make sure it is an overlying USDT, stapsdt probe. */ + if (prp->prov->impl != &dt_usdt && prp->prov->impl != &dt_stapsdt) continue; /* FIXME passing in NULL pcb and dpr wreaks havoc on error reporting? */ @@ -637,6 +641,7 @@ static int add_probe_uprobe(dtrace_hdl_t *dtp, dt_probe_t *prp) return 0; } +/* shared between usdt, stapsdt probes */ static int add_probe_usdt(dtrace_hdl_t *dtp, dt_probe_t *prp) { char probnam[DTRACE_FULLNAMELEN], *p; @@ -890,6 +895,7 @@ static dt_probe_t *create_underlying(dtrace_hdl_t *dtp, case DTPPT_OFFSETS: case DTPPT_ABSOFFSETS: case DTPPT_USDT: + case DTPPT_STAPSDT: snprintf(prb, sizeof(prb), "%lx", psp->pps_off); break; default: @@ -904,7 +910,7 @@ static dt_probe_t *create_underlying(dtrace_hdl_t *dtp, pd.prb = prb; dt_dprintf("Providing underlying probe %s:%s:%s:%s @ %lx\n", psp->pps_prv, - psp->pps_mod, psp->pps_fn, psp->pps_prb, psp->pps_off); + psp->pps_mod, psp->pps_fun, psp->pps_prb, psp->pps_off); uprp = dt_probe_lookup(dtp, &pd); if (uprp == NULL) { dt_provider_t *pvp; @@ -922,6 +928,7 @@ static dt_probe_t *create_underlying(dtrace_hdl_t *dtp, upp->dev = psp->pps_dev; upp->inum = psp->pps_inum; upp->off = psp->pps_off; + upp->refcntr_off = psp->pps_refcntr_off; upp->fn = strdup(psp->pps_fn); upp->func = NULL; upp->tp = dt_tp_alloc(dtp); @@ -1108,11 +1115,24 @@ static int provide_usdt_probe(dtrace_hdl_t *dtp, const pid_probespec_t *psp) return provide_probe(dtp, psp, psp->pps_prb, &dt_usdt, PP_IS_FUNCALL); } +static int provide_stapsdt_probe(dtrace_hdl_t *dtp, const pid_probespec_t *psp) +{ + if (psp->pps_type != DTPPT_STAPSDT && + psp->pps_type != DTPPT_IS_ENABLED) { + dt_dprintf("pid: unknown stapsdt probe type %i\n", psp->pps_type); + return -1; + } + + return provide_probe(dtp, psp, psp->pps_prb, &dt_stapsdt, PP_IS_FUNCALL); +} + + static void enable(dtrace_hdl_t *dtp, dt_probe_t *prp, int is_usdt) { const list_probe_t *pup; - assert(prp->prov->impl == &dt_pid || prp->prov->impl == &dt_usdt); + assert(prp->prov->impl == &dt_pid || prp->prov->impl == &dt_usdt || + prp->prov->impl == &dt_stapsdt); /* * We need to enable the underlying probes (if not enabled yet). @@ -1144,6 +1164,11 @@ static void enable_usdt(dtrace_hdl_t *dtp, dt_probe_t *prp) enable(dtp, prp, 1); } +static void enable_stapsdt(dtrace_hdl_t *dtp, dt_probe_t *prp) +{ + enable(dtp, prp, 1); +} + /* * Generate code that populates, counts the probe arguments. */ @@ -1652,17 +1677,25 @@ static char *uprobe_name(dev_t dev, ino_t ino, uint64_t addr, int flags) * Create a uprobe for a given dev/ino, mapping filename, and address: the * uprobe may be a uretprobe. Return the probe's name as * a new dynamically-allocated string, or NULL on error. + * + * An optional refcntr_off - used by stapsdt probes to identify semaphore + * address - can also be supplied. */ static char *uprobe_create(dev_t dev, ino_t ino, const char *mapping_fn, - uint64_t addr, int flags) + uint64_t addr, uint64_t refcntr_off, int flags) { int fd = -1; int rc = -1; char *name; char *spec; - if (asprintf(&spec, "%s:0x%lx", mapping_fn, addr) < 0) - return NULL; + if (refcntr_off) { + if (asprintf(&spec, "%s:0x%lx(0x%lx)", mapping_fn, addr, refcntr_off) < 0) + return NULL; + } else { + if (asprintf(&spec, "%s:0x%lx", mapping_fn, addr) < 0) + return NULL; + } name = uprobe_name(dev, ino, addr, flags); if (!name) @@ -1701,7 +1734,7 @@ static int attach(dtrace_hdl_t *dtp, const dt_probe_t *uprp, int bpf_fd) assert(upp->fn != NULL); prb = uprobe_create(upp->dev, upp->inum, upp->fn, upp->off, - upp->flags); + upp->refcntr_off, upp->flags); /* * If the uprobe creation failed, it is possible it already @@ -1875,3 +1908,15 @@ dt_provimpl_t dt_usdt = { .discover = &discover, .add_probe = &add_probe_usdt, }; + +/* + * Used for stapsdt probes. + */ +dt_provimpl_t dt_stapsdt = { + .name = "stapsdt", + .prog_type = BPF_PROG_TYPE_UNSPEC, + .provide_probe = &provide_stapsdt_probe, + .enable = &enable_stapsdt, + .probe_destroy = &probe_destroy, + .add_probe = &add_probe_usdt, +}; -- 2.39.3 ^ permalink raw reply related [flat|nested] 12+ messages in thread
* [PATCH v6 3/7] selftests/usdt: add test for stapsdt note-defined probe firing, args 2025-07-28 16:36 [PATCH v6 0/7] add support for stapsdt probes Alan Maguire 2025-07-28 16:36 ` [PATCH v6 1/7] usdt: have copy_args() count args while parsing them Alan Maguire 2025-07-28 16:36 ` [PATCH v6 2/7] support stapsdt ELF-note-defined static probes Alan Maguire @ 2025-07-28 16:36 ` Alan Maguire 2025-07-28 16:36 ` [PATCH v6 4/7] selftests/usdt: add test for stapsdt notes in shared library Alan Maguire ` (3 subsequent siblings) 6 siblings, 0 replies; 12+ messages in thread From: Alan Maguire @ 2025-07-28 16:36 UTC (permalink / raw) To: dtrace; +Cc: dtrace-devel, Alan Maguire Add test identical to the args tests to verify probe firing and arg retrieval work for stapsdt notes-defined STAP_PROBEn() probes. Need a copy of the sdt.h file which is public domain, so add it in the test directory. Signed-off-by: Alan Maguire <alan.maguire@oracle.com> --- test/unittest/usdt/sdt_notes.h | 504 ++++++++++++++++++++++++ test/unittest/usdt/tst.stapsdt-notes.r | 14 + test/unittest/usdt/tst.stapsdt-notes.sh | 121 ++++++ 3 files changed, 639 insertions(+) create mode 100644 test/unittest/usdt/sdt_notes.h create mode 100644 test/unittest/usdt/tst.stapsdt-notes.r create mode 100755 test/unittest/usdt/tst.stapsdt-notes.sh diff --git a/test/unittest/usdt/sdt_notes.h b/test/unittest/usdt/sdt_notes.h new file mode 100644 index 00000000..ec5423e2 --- /dev/null +++ b/test/unittest/usdt/sdt_notes.h @@ -0,0 +1,504 @@ +/* <sys/sdt.h> - Systemtap static probe definition macros. + + This file is dedicated to the public domain, pursuant to CC0 + (https://creativecommons.org/publicdomain/zero/1.0/) +*/ + +#ifndef _SYS_SDT_H +#define _SYS_SDT_H 1 + +/* + This file defines a family of macros + + STAP_PROBEn(op1, ..., opn) + + that emit a nop into the instruction stream, and some data into an auxiliary + note section. The data in the note section describes the operands, in terms + of size and location. Each location is encoded as assembler operand string. + Consumer tools such as gdb or systemtap insert breakpoints on top of + the nop, and decode the location operand-strings, like an assembler, + to find the values being passed. + + The operand strings are selected by the compiler for each operand. + They are constrained by gcc inline-assembler codes. The default is: + + #define STAP_SDT_ARG_CONSTRAINT nor + + This is a good default if the operands tend to be integral and + moderate in number (smaller than number of registers). In other + cases, the compiler may report "'asm' requires impossible reload" or + similar. In this case, consider simplifying the macro call (fewer + and simpler operands), reduce optimization, or override the default + constraints string via: + + #define STAP_SDT_ARG_CONSTRAINT g + #include <sys/sdt.h> + + See also: + https://sourceware.org/systemtap/wiki/UserSpaceProbeImplementation + https://gcc.gnu.org/onlinedocs/gcc/Constraints.html + */ + + + +#ifdef __ASSEMBLER__ +# define _SDT_PROBE(provider, name, n, arglist) \ + _SDT_ASM_BODY(provider, name, _SDT_ASM_SUBSTR_1, (_SDT_DEPAREN_##n arglist)) \ + _SDT_ASM_BASE +# define _SDT_ASM_1(x) x; +# define _SDT_ASM_2(a, b) a,b; +# define _SDT_ASM_3(a, b, c) a,b,c; +# define _SDT_ASM_5(a, b, c, d, e) a,b,c,d,e; +# define _SDT_ASM_STRING_1(x) .asciz #x; +# define _SDT_ASM_SUBSTR_1(x) .ascii #x; +# define _SDT_DEPAREN_0() /* empty */ +# define _SDT_DEPAREN_1(a) a +# define _SDT_DEPAREN_2(a,b) a b +# define _SDT_DEPAREN_3(a,b,c) a b c +# define _SDT_DEPAREN_4(a,b,c,d) a b c d +# define _SDT_DEPAREN_5(a,b,c,d,e) a b c d e +# define _SDT_DEPAREN_6(a,b,c,d,e,f) a b c d e f +# define _SDT_DEPAREN_7(a,b,c,d,e,f,g) a b c d e f g +# define _SDT_DEPAREN_8(a,b,c,d,e,f,g,h) a b c d e f g h +# define _SDT_DEPAREN_9(a,b,c,d,e,f,g,h,i) a b c d e f g h i +# define _SDT_DEPAREN_10(a,b,c,d,e,f,g,h,i,j) a b c d e f g h i j +# define _SDT_DEPAREN_11(a,b,c,d,e,f,g,h,i,j,k) a b c d e f g h i j k +# define _SDT_DEPAREN_12(a,b,c,d,e,f,g,h,i,j,k,l) a b c d e f g h i j k l +#else +#if defined _SDT_HAS_SEMAPHORES +#define _SDT_NOTE_SEMAPHORE_USE(provider, name) \ + __asm__ __volatile__ ("" :: "m" (provider##_##name##_semaphore)); +#else +#define _SDT_NOTE_SEMAPHORE_USE(provider, name) +#endif + +# define _SDT_PROBE(provider, name, n, arglist) \ + do { \ + _SDT_NOTE_SEMAPHORE_USE(provider, name); \ + __asm__ __volatile__ (_SDT_ASM_BODY(provider, name, _SDT_ASM_ARGS, (n)) \ + :: _SDT_ASM_OPERANDS_##n arglist); \ + __asm__ __volatile__ (_SDT_ASM_BASE); \ + } while (0) +# define _SDT_S(x) #x +# define _SDT_ASM_1(x) _SDT_S(x) "\n" +# define _SDT_ASM_2(a, b) _SDT_S(a) "," _SDT_S(b) "\n" +# define _SDT_ASM_3(a, b, c) _SDT_S(a) "," _SDT_S(b) "," \ + _SDT_S(c) "\n" +# define _SDT_ASM_5(a, b, c, d, e) _SDT_S(a) "," _SDT_S(b) "," \ + _SDT_S(c) "," _SDT_S(d) "," \ + _SDT_S(e) "\n" +# define _SDT_ASM_ARGS(n) _SDT_ASM_TEMPLATE_##n +# define _SDT_ASM_STRING_1(x) _SDT_ASM_1(.asciz #x) +# define _SDT_ASM_SUBSTR_1(x) _SDT_ASM_1(.ascii #x) + +# define _SDT_ARGFMT(no) _SDT_ASM_1(_SDT_SIGN %n[_SDT_S##no]) \ + _SDT_ASM_1(_SDT_SIZE %n[_SDT_S##no]) \ + _SDT_ASM_1(_SDT_TYPE %n[_SDT_S##no]) \ + _SDT_ASM_SUBSTR(_SDT_ARGTMPL(_SDT_A##no)) + + +# ifndef STAP_SDT_ARG_CONSTRAINT +# if defined __powerpc__ +# define STAP_SDT_ARG_CONSTRAINT nZr +# elif defined __arm__ +# define STAP_SDT_ARG_CONSTRAINT g +# else +# define STAP_SDT_ARG_CONSTRAINT nor +# endif +# endif + +# define _SDT_STRINGIFY(x) #x +# define _SDT_ARG_CONSTRAINT_STRING(x) _SDT_STRINGIFY(x) +/* _SDT_S encodes the size and type as 0xSSTT which is decoded by the assembler + macros _SDT_SIZE and _SDT_TYPE */ +# define _SDT_ARG(n, x) \ + [_SDT_S##n] "n" ((_SDT_ARGSIGNED (x) ? (int)-1 : 1) * (-(((int) _SDT_ARGSIZE (x)) << 8) + (-(0x7f & __builtin_classify_type (x))))), \ + [_SDT_A##n] _SDT_ARG_CONSTRAINT_STRING (STAP_SDT_ARG_CONSTRAINT) (_SDT_ARGVAL (x)) +#endif +#define _SDT_ASM_STRING(x) _SDT_ASM_STRING_1(x) +#define _SDT_ASM_SUBSTR(x) _SDT_ASM_SUBSTR_1(x) + +#define _SDT_ARGARRAY(x) (__builtin_classify_type (x) == 14 \ + || __builtin_classify_type (x) == 5) + +#ifdef __cplusplus +# define _SDT_ARGSIGNED(x) (!_SDT_ARGARRAY (x) \ + && __sdt_type<__typeof (x)>::__sdt_signed) +# define _SDT_ARGSIZE(x) (_SDT_ARGARRAY (x) \ + ? sizeof (void *) : sizeof (x)) +# define _SDT_ARGVAL(x) (x) + +# include <cstddef> + +template<typename __sdt_T> +struct __sdt_type +{ + static const bool __sdt_signed = false; +}; + +#define __SDT_ALWAYS_SIGNED(T) \ +template<> struct __sdt_type<T> { static const bool __sdt_signed = true; }; +#define __SDT_COND_SIGNED(T,CT) \ +template<> struct __sdt_type<T> { static const bool __sdt_signed = ((CT)(-1) < 1); }; +__SDT_ALWAYS_SIGNED(signed char) +__SDT_ALWAYS_SIGNED(short) +__SDT_ALWAYS_SIGNED(int) +__SDT_ALWAYS_SIGNED(long) +__SDT_ALWAYS_SIGNED(long long) +__SDT_ALWAYS_SIGNED(volatile signed char) +__SDT_ALWAYS_SIGNED(volatile short) +__SDT_ALWAYS_SIGNED(volatile int) +__SDT_ALWAYS_SIGNED(volatile long) +__SDT_ALWAYS_SIGNED(volatile long long) +__SDT_ALWAYS_SIGNED(const signed char) +__SDT_ALWAYS_SIGNED(const short) +__SDT_ALWAYS_SIGNED(const int) +__SDT_ALWAYS_SIGNED(const long) +__SDT_ALWAYS_SIGNED(const long long) +__SDT_ALWAYS_SIGNED(const volatile signed char) +__SDT_ALWAYS_SIGNED(const volatile short) +__SDT_ALWAYS_SIGNED(const volatile int) +__SDT_ALWAYS_SIGNED(const volatile long) +__SDT_ALWAYS_SIGNED(const volatile long long) +__SDT_COND_SIGNED(char, char) +__SDT_COND_SIGNED(wchar_t, wchar_t) +__SDT_COND_SIGNED(volatile char, char) +__SDT_COND_SIGNED(volatile wchar_t, wchar_t) +__SDT_COND_SIGNED(const char, char) +__SDT_COND_SIGNED(const wchar_t, wchar_t) +__SDT_COND_SIGNED(const volatile char, char) +__SDT_COND_SIGNED(const volatile wchar_t, wchar_t) +#if defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) +/* __SDT_COND_SIGNED(char16_t) */ +/* __SDT_COND_SIGNED(char32_t) */ +#endif + +template<typename __sdt_E> +struct __sdt_type<__sdt_E[]> : public __sdt_type<__sdt_E *> {}; + +template<typename __sdt_E, size_t __sdt_N> +struct __sdt_type<__sdt_E[__sdt_N]> : public __sdt_type<__sdt_E *> {}; + +#elif !defined(__ASSEMBLER__) +__extension__ extern unsigned long long __sdt_unsp; +# define _SDT_ARGINTTYPE(x) \ + __typeof (__builtin_choose_expr (((__builtin_classify_type (x) \ + + 3) & -4) == 4, (x), 0U)) +# define _SDT_ARGSIGNED(x) \ + (!__extension__ \ + (__builtin_constant_p ((((unsigned long long) \ + (_SDT_ARGINTTYPE (x)) __sdt_unsp) \ + & ((unsigned long long)1 << (sizeof (unsigned long long) \ + * __CHAR_BIT__ - 1))) == 0) \ + || (_SDT_ARGINTTYPE (x)) -1 > (_SDT_ARGINTTYPE (x)) 0)) +# define _SDT_ARGSIZE(x) \ + (_SDT_ARGARRAY (x) ? sizeof (void *) : sizeof (x)) +# define _SDT_ARGVAL(x) (x) +#endif + +#if defined __powerpc__ || defined __powerpc64__ +# define _SDT_ARGTMPL(id) %I[id]%[id] +#elif defined __i386__ +# define _SDT_ARGTMPL(id) %k[id] /* gcc.gnu.org/PR80115 sourceware.org/PR24541 */ +#else +# define _SDT_ARGTMPL(id) %[id] +#endif + +/* NB: gdb PR24541 highlighted an unspecified corner of the sdt.h + operand note format. + + The named register may be a longer or shorter (!) alias for the + storage where the value in question is found. For example, on + i386, 64-bit value may be put in register pairs, and the register + name stored would identify just one of them. Previously, gcc was + asked to emit the %w[id] (16-bit alias of some registers holding + operands), even when a wider 32-bit value was used. + + Bottom line: the byte-width given before the @ sign governs. If + there is a mismatch between that width and that of the named + register, then a sys/sdt.h note consumer may need to employ + architecture-specific heuristics to figure out where the compiler + has actually put the complete value. +*/ + +#ifdef __LP64__ +# define _SDT_ASM_ADDR .8byte +#else +# define _SDT_ASM_ADDR .4byte +#endif + +/* The ia64 and s390 nop instructions take an argument. */ +#if defined(__ia64__) || defined(__s390__) || defined(__s390x__) +#define _SDT_NOP nop 0 +#else +#define _SDT_NOP nop +#endif + +#define _SDT_NOTE_NAME "stapsdt" +#define _SDT_NOTE_TYPE 3 + +# define _SDT_ASM_AUTOGROUP "?" + +#define _SDT_DEF_MACROS \ + _SDT_ASM_1(.altmacro) \ + _SDT_ASM_1(.macro _SDT_SIGN x) \ + _SDT_ASM_3(.pushsection .note.stapsdt,"","note") \ + _SDT_ASM_1(.iflt \\x) \ + _SDT_ASM_1(.ascii "-") \ + _SDT_ASM_1(.endif) \ + _SDT_ASM_1(.popsection) \ + _SDT_ASM_1(.endm) \ + _SDT_ASM_1(.macro _SDT_SIZE_ x) \ + _SDT_ASM_3(.pushsection .note.stapsdt,"","note") \ + _SDT_ASM_1(.ascii "\x") \ + _SDT_ASM_1(.popsection) \ + _SDT_ASM_1(.endm) \ + _SDT_ASM_1(.macro _SDT_SIZE x) \ + _SDT_ASM_1(_SDT_SIZE_ %%((-(-\\x*((-\\x>0)-(-\\x<0))))>>8)) \ + _SDT_ASM_1(.endm) \ + _SDT_ASM_1(.macro _SDT_TYPE_ x) \ + _SDT_ASM_3(.pushsection .note.stapsdt,"","note") \ + _SDT_ASM_2(.ifc 8,\\x) \ + _SDT_ASM_1(.ascii "f") \ + _SDT_ASM_1(.endif) \ + _SDT_ASM_1(.ascii "@") \ + _SDT_ASM_1(.popsection) \ + _SDT_ASM_1(.endm) \ + _SDT_ASM_1(.macro _SDT_TYPE x) \ + _SDT_ASM_1(_SDT_TYPE_ %%((\\x)&(0xff))) \ + _SDT_ASM_1(.endm) + +#define _SDT_UNDEF_MACROS \ + _SDT_ASM_1(.purgem _SDT_SIGN) \ + _SDT_ASM_1(.purgem _SDT_SIZE_) \ + _SDT_ASM_1(.purgem _SDT_SIZE) \ + _SDT_ASM_1(.purgem _SDT_TYPE_) \ + _SDT_ASM_1(.purgem _SDT_TYPE) + +#define _SDT_ASM_BODY(provider, name, pack_args, args, ...) \ + _SDT_DEF_MACROS \ + _SDT_ASM_1(990: _SDT_NOP) \ + _SDT_ASM_3( .pushsection .note.stapsdt,_SDT_ASM_AUTOGROUP,"note") \ + _SDT_ASM_1( .balign 4) \ + _SDT_ASM_3( .4byte 992f-991f, 994f-993f, _SDT_NOTE_TYPE) \ + _SDT_ASM_1(991: .asciz _SDT_NOTE_NAME) \ + _SDT_ASM_1(992: .balign 4) \ + _SDT_ASM_1(993: _SDT_ASM_ADDR 990b) \ + _SDT_ASM_1( _SDT_ASM_ADDR _.stapsdt.base) \ + _SDT_SEMAPHORE(provider,name) \ + _SDT_ASM_STRING(provider) \ + _SDT_ASM_STRING(name) \ + pack_args args \ + _SDT_ASM_SUBSTR(\x00) \ + _SDT_UNDEF_MACROS \ + _SDT_ASM_1(994: .balign 4) \ + _SDT_ASM_1( .popsection) + +#define _SDT_ASM_BASE \ + _SDT_ASM_1(.ifndef _.stapsdt.base) \ + _SDT_ASM_5( .pushsection .stapsdt.base,"aG","progbits", \ + .stapsdt.base,comdat) \ + _SDT_ASM_1( .weak _.stapsdt.base) \ + _SDT_ASM_1( .hidden _.stapsdt.base) \ + _SDT_ASM_1( _.stapsdt.base: .space 1) \ + _SDT_ASM_2( .size _.stapsdt.base, 1) \ + _SDT_ASM_1( .popsection) \ + _SDT_ASM_1(.endif) + +#if defined _SDT_HAS_SEMAPHORES +#define _SDT_SEMAPHORE(p,n) \ + _SDT_ASM_1( _SDT_ASM_ADDR p##_##n##_semaphore) +#else +#define _SDT_SEMAPHORE(p,n) _SDT_ASM_1( _SDT_ASM_ADDR 0) +#endif + +#define _SDT_ASM_BLANK _SDT_ASM_SUBSTR(\x20) +#define _SDT_ASM_TEMPLATE_0 /* no arguments */ +#define _SDT_ASM_TEMPLATE_1 _SDT_ARGFMT(1) +#define _SDT_ASM_TEMPLATE_2 _SDT_ASM_TEMPLATE_1 _SDT_ASM_BLANK _SDT_ARGFMT(2) +#define _SDT_ASM_TEMPLATE_3 _SDT_ASM_TEMPLATE_2 _SDT_ASM_BLANK _SDT_ARGFMT(3) +#define _SDT_ASM_TEMPLATE_4 _SDT_ASM_TEMPLATE_3 _SDT_ASM_BLANK _SDT_ARGFMT(4) +#define _SDT_ASM_TEMPLATE_5 _SDT_ASM_TEMPLATE_4 _SDT_ASM_BLANK _SDT_ARGFMT(5) +#define _SDT_ASM_TEMPLATE_6 _SDT_ASM_TEMPLATE_5 _SDT_ASM_BLANK _SDT_ARGFMT(6) +#define _SDT_ASM_TEMPLATE_7 _SDT_ASM_TEMPLATE_6 _SDT_ASM_BLANK _SDT_ARGFMT(7) +#define _SDT_ASM_TEMPLATE_8 _SDT_ASM_TEMPLATE_7 _SDT_ASM_BLANK _SDT_ARGFMT(8) +#define _SDT_ASM_TEMPLATE_9 _SDT_ASM_TEMPLATE_8 _SDT_ASM_BLANK _SDT_ARGFMT(9) +#define _SDT_ASM_TEMPLATE_10 _SDT_ASM_TEMPLATE_9 _SDT_ASM_BLANK _SDT_ARGFMT(10) +#define _SDT_ASM_TEMPLATE_11 _SDT_ASM_TEMPLATE_10 _SDT_ASM_BLANK _SDT_ARGFMT(11) +#define _SDT_ASM_TEMPLATE_12 _SDT_ASM_TEMPLATE_11 _SDT_ASM_BLANK _SDT_ARGFMT(12) +#define _SDT_ASM_OPERANDS_0() [__sdt_dummy] "g" (0) +#define _SDT_ASM_OPERANDS_1(arg1) _SDT_ARG(1, arg1) +#define _SDT_ASM_OPERANDS_2(arg1, arg2) \ + _SDT_ASM_OPERANDS_1(arg1), _SDT_ARG(2, arg2) +#define _SDT_ASM_OPERANDS_3(arg1, arg2, arg3) \ + _SDT_ASM_OPERANDS_2(arg1, arg2), _SDT_ARG(3, arg3) +#define _SDT_ASM_OPERANDS_4(arg1, arg2, arg3, arg4) \ + _SDT_ASM_OPERANDS_3(arg1, arg2, arg3), _SDT_ARG(4, arg4) +#define _SDT_ASM_OPERANDS_5(arg1, arg2, arg3, arg4, arg5) \ + _SDT_ASM_OPERANDS_4(arg1, arg2, arg3, arg4), _SDT_ARG(5, arg5) +#define _SDT_ASM_OPERANDS_6(arg1, arg2, arg3, arg4, arg5, arg6) \ + _SDT_ASM_OPERANDS_5(arg1, arg2, arg3, arg4, arg5), _SDT_ARG(6, arg6) +#define _SDT_ASM_OPERANDS_7(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \ + _SDT_ASM_OPERANDS_6(arg1, arg2, arg3, arg4, arg5, arg6), _SDT_ARG(7, arg7) +#define _SDT_ASM_OPERANDS_8(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \ + _SDT_ASM_OPERANDS_7(arg1, arg2, arg3, arg4, arg5, arg6, arg7), \ + _SDT_ARG(8, arg8) +#define _SDT_ASM_OPERANDS_9(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9) \ + _SDT_ASM_OPERANDS_8(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8), \ + _SDT_ARG(9, arg9) +#define _SDT_ASM_OPERANDS_10(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10) \ + _SDT_ASM_OPERANDS_9(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9), \ + _SDT_ARG(10, arg10) +#define _SDT_ASM_OPERANDS_11(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11) \ + _SDT_ASM_OPERANDS_10(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10), \ + _SDT_ARG(11, arg11) +#define _SDT_ASM_OPERANDS_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12) \ + _SDT_ASM_OPERANDS_11(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11), \ + _SDT_ARG(12, arg12) + +/* These macros can be used in C, C++, or assembly code. + In assembly code the arguments should use normal assembly operand syntax. */ + +#define STAP_PROBE(provider, name) \ + _SDT_PROBE(provider, name, 0, ()) +#define STAP_PROBE1(provider, name, arg1) \ + _SDT_PROBE(provider, name, 1, (arg1)) +#define STAP_PROBE2(provider, name, arg1, arg2) \ + _SDT_PROBE(provider, name, 2, (arg1, arg2)) +#define STAP_PROBE3(provider, name, arg1, arg2, arg3) \ + _SDT_PROBE(provider, name, 3, (arg1, arg2, arg3)) +#define STAP_PROBE4(provider, name, arg1, arg2, arg3, arg4) \ + _SDT_PROBE(provider, name, 4, (arg1, arg2, arg3, arg4)) +#define STAP_PROBE5(provider, name, arg1, arg2, arg3, arg4, arg5) \ + _SDT_PROBE(provider, name, 5, (arg1, arg2, arg3, arg4, arg5)) +#define STAP_PROBE6(provider, name, arg1, arg2, arg3, arg4, arg5, arg6) \ + _SDT_PROBE(provider, name, 6, (arg1, arg2, arg3, arg4, arg5, arg6)) +#define STAP_PROBE7(provider, name, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \ + _SDT_PROBE(provider, name, 7, (arg1, arg2, arg3, arg4, arg5, arg6, arg7)) +#define STAP_PROBE8(provider,name,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8) \ + _SDT_PROBE(provider, name, 8, (arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8)) +#define STAP_PROBE9(provider,name,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9)\ + _SDT_PROBE(provider, name, 9, (arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9)) +#define STAP_PROBE10(provider,name,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10) \ + _SDT_PROBE(provider, name, 10, \ + (arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10)) +#define STAP_PROBE11(provider,name,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11) \ + _SDT_PROBE(provider, name, 11, \ + (arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11)) +#define STAP_PROBE12(provider,name,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12) \ + _SDT_PROBE(provider, name, 12, \ + (arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12)) + +/* This STAP_PROBEV macro can be used in variadic scenarios, where the + number of probe arguments is not known until compile time. Since + variadic macro support may vary with compiler options, you must + pre-#define SDT_USE_VARIADIC to enable this type of probe. + + The trick to count __VA_ARGS__ was inspired by this post by + Laurent Deniau <laurent.deniau@cern.ch>: + http://groups.google.com/group/comp.std.c/msg/346fc464319b1ee5 + + Note that our _SDT_NARG is called with an extra 0 arg that's not + counted, so we don't have to worry about the behavior of macros + called without any arguments. */ + +#define _SDT_NARG(...) __SDT_NARG(__VA_ARGS__, 12,11,10,9,8,7,6,5,4,3,2,1,0) +#define __SDT_NARG(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12, N, ...) N +#ifdef SDT_USE_VARIADIC +#define _SDT_PROBE_N(provider, name, N, ...) \ + _SDT_PROBE(provider, name, N, (__VA_ARGS__)) +#define STAP_PROBEV(provider, name, ...) \ + _SDT_PROBE_N(provider, name, _SDT_NARG(0, ##__VA_ARGS__), ##__VA_ARGS__) +#endif + +/* These macros are for use in asm statements. You must compile + with -std=gnu99 or -std=c99 to use the STAP_PROBE_ASM macro. + + The STAP_PROBE_ASM macro generates a quoted string to be used in the + template portion of the asm statement, concatenated with strings that + contain the actual assembly code around the probe site. + + For example: + + asm ("before\n" + STAP_PROBE_ASM(provider, fooprobe, %eax 4(%esi)) + "after"); + + emits the assembly code for "before\nafter", with a probe in between. + The probe arguments are the %eax register, and the value of the memory + word located 4 bytes past the address in the %esi register. Note that + because this is a simple asm, not a GNU C extended asm statement, these + % characters do not need to be doubled to generate literal %reg names. + + In a GNU C extended asm statement, the probe arguments can be specified + using the macro STAP_PROBE_ASM_TEMPLATE(n) for n arguments. The paired + macro STAP_PROBE_ASM_OPERANDS gives the C values of these probe arguments, + and appears in the input operand list of the asm statement. For example: + + asm ("someinsn %0,%1\n" // %0 is output operand, %1 is input operand + STAP_PROBE_ASM(provider, fooprobe, STAP_PROBE_ASM_TEMPLATE(3)) + "otherinsn %[namedarg]" + : "r" (outvar) + : "g" (some_value), [namedarg] "i" (1234), + STAP_PROBE_ASM_OPERANDS(3, some_value, some_ptr->field, 1234)); + + This is just like writing: + + STAP_PROBE3(provider, fooprobe, some_value, some_ptr->field, 1234)); + + but the probe site is right between "someinsn" and "otherinsn". + + The probe arguments in STAP_PROBE_ASM can be given as assembly + operands instead, even inside a GNU C extended asm statement. + Note that these can use operand templates like %0 or %[name], + and likewise they must write %%reg for a literal operand of %reg. */ + +#define _SDT_ASM_BODY_1(p,n,...) _SDT_ASM_BODY(p,n,_SDT_ASM_SUBSTR,(__VA_ARGS__)) +#define _SDT_ASM_BODY_2(p,n,...) _SDT_ASM_BODY(p,n,/*_SDT_ASM_STRING */,__VA_ARGS__) +#define _SDT_ASM_BODY_N2(p,n,no,...) _SDT_ASM_BODY_ ## no(p,n,__VA_ARGS__) +#define _SDT_ASM_BODY_N1(p,n,no,...) _SDT_ASM_BODY_N2(p,n,no,__VA_ARGS__) +#define _SDT_ASM_BODY_N(p,n,...) _SDT_ASM_BODY_N1(p,n,_SDT_NARG(0, __VA_ARGS__),__VA_ARGS__) + +#if __STDC_VERSION__ >= 199901L +# define STAP_PROBE_ASM(provider, name, ...) \ + _SDT_ASM_BODY_N(provider, name, __VA_ARGS__) \ + _SDT_ASM_BASE +# define STAP_PROBE_ASM_OPERANDS(n, ...) _SDT_ASM_OPERANDS_##n(__VA_ARGS__) +#else +# define STAP_PROBE_ASM(provider, name, args) \ + _SDT_ASM_BODY(provider, name, /* _SDT_ASM_STRING */, (args)) \ + _SDT_ASM_BASE +#endif +#define STAP_PROBE_ASM_TEMPLATE(n) _SDT_ASM_TEMPLATE_##n,"use _SDT_ASM_TEMPLATE_" + + +/* DTrace compatible macro names. */ +#define DTRACE_PROBE(provider,probe) \ + STAP_PROBE(provider,probe) +#define DTRACE_PROBE1(provider,probe,parm1) \ + STAP_PROBE1(provider,probe,parm1) +#define DTRACE_PROBE2(provider,probe,parm1,parm2) \ + STAP_PROBE2(provider,probe,parm1,parm2) +#define DTRACE_PROBE3(provider,probe,parm1,parm2,parm3) \ + STAP_PROBE3(provider,probe,parm1,parm2,parm3) +#define DTRACE_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \ + STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) +#define DTRACE_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \ + STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) +#define DTRACE_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \ + STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) +#define DTRACE_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \ + STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) +#define DTRACE_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \ + STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) +#define DTRACE_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \ + STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) +#define DTRACE_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \ + STAP_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) +#define DTRACE_PROBE11(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10,parm11) \ + STAP_PROBE11(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10,parm11) +#define DTRACE_PROBE12(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10,parm11,parm12) \ + STAP_PROBE12(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10,parm11,parm12) + + +#endif /* sys/sdt.h */ diff --git a/test/unittest/usdt/tst.stapsdt-notes.r b/test/unittest/usdt/tst.stapsdt-notes.r new file mode 100644 index 00000000..db6d18cb --- /dev/null +++ b/test/unittest/usdt/tst.stapsdt-notes.r @@ -0,0 +1,14 @@ +test:main:zero +test:main:one:1 +test:main:two:2:3 +test:main:three:4:5:7 +test:main:four:7:8:9:10 +test:main:five:11:12:13:14:15 +test:main:six:16:17:18:19:20:21 +test:main:seven:22:23:24:25:26:27:28 +test:main:eight:29:30:31:32:33:34:35:36 +test:main:nine:37:38:39:40:41:42:43:44:45 +test:main:ten:46:47:48:49:50:51:52:53:54:55 +test:main:eleven:56:57:58:59:60:61:62:63:64:65 +test:main:twelve:67:68:69:70:71:72:73:74:75:76 + diff --git a/test/unittest/usdt/tst.stapsdt-notes.sh b/test/unittest/usdt/tst.stapsdt-notes.sh new file mode 100755 index 00000000..1d132a59 --- /dev/null +++ b/test/unittest/usdt/tst.stapsdt-notes.sh @@ -0,0 +1,121 @@ +#!/bin/bash +# +# Oracle Linux DTrace. +# Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. +# Licensed under the Universal Permissive License v 1.0 as shown at +# http://oss.oracle.com/licenses/upl. + +# This test covers all stapsdt probes fired by the STAP_PROBEn macros. +# Arguments values are checked only for first 10 arguments because +# there is support for arg0 ... arg9 only at this moment. + +if [ $# != 1 ]; then + echo expected one argument: '<'dtrace-path'>' + exit 2 +fi + +dtrace=$1 +CC=/usr/bin/gcc +CFLAGS="-I${PWD}/test/unittest/usdt" + +DIRNAME="$tmpdir/usdt-notes.$$.$RANDOM" +mkdir -p $DIRNAME +cd $DIRNAME + +cat > test.c <<EOF +#include <sdt_notes.h> + +int +main(int argc, char **argv) +{ + STAP_PROBE(test_prov, zero); + STAP_PROBE1(test_prov, one, argc); + STAP_PROBE2(test_prov, two, 2, 3); + STAP_PROBE3(test_prov, three, 4, 5, 7); + STAP_PROBE4(test_prov, four, 7, 8, 9, 10); + STAP_PROBE5(test_prov, five, 11, 12, 13, 14, 15); + STAP_PROBE6(test_prov, six, 16, 17, 18, 19, 20, 21); + STAP_PROBE7(test_prov, seven, 22, 23, 24, 25, 26, 27, 28); + STAP_PROBE8(test_prov, eight, 29, 30, 31, 32, 33, 34, 35, 36); + STAP_PROBE9(test_prov, nine, 37, 38, 39, 40, 41, 42, 43, 44, 45); + STAP_PROBE10(test_prov, ten, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55); + STAP_PROBE11(test_prov, eleven, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66); + STAP_PROBE12(test_prov, twelve, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78); +} +EOF + +${CC} ${CFLAGS} -o test test.c +if [ $? -ne 0 ]; then + echo "failed to compile test.c" >& 2 + exit 1 +fi + +$dtrace -c ./test -qs /dev/stdin <<EOF +test_prov\$target:::zero +{ + printf("%s:%s:%s\n", probemod, probefunc, probename); +} + +test_prov\$target:::one +{ + printf("%s:%s:%s:%li\n", probemod, probefunc, probename, arg0); +} + +test_prov\$target:::two +{ + printf("%s:%s:%s:%li:%li\n", probemod, probefunc, probename, arg0, arg1); +} + +test_prov\$target:::three +{ + printf("%s:%s:%s:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, + arg2); +} + +test_prov\$target:::four +{ + printf("%s:%s:%s:%li:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, + arg2, arg3); +} + +test_prov\$target:::five +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4); +} + +test_prov\$target:::six +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5); +} + +test_prov\$target:::seven +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6); +} + +test_prov\$target:::eight +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); +} + +test_prov\$target:::nine +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); +} + +test_prov\$target:::ten, +test_prov\$target:::eleven, +test_prov\$target:::twelve +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); +} +EOF +status=$? + +exit $status -- 2.39.3 ^ permalink raw reply related [flat|nested] 12+ messages in thread
* [PATCH v6 4/7] selftests/usdt: add test for stapsdt notes in shared library 2025-07-28 16:36 [PATCH v6 0/7] add support for stapsdt probes Alan Maguire ` (2 preceding siblings ...) 2025-07-28 16:36 ` [PATCH v6 3/7] selftests/usdt: add test for stapsdt note-defined probe firing, args Alan Maguire @ 2025-07-28 16:36 ` Alan Maguire 2025-07-28 16:36 ` [PATCH v6 5/7] selftests/usdt: add test covering different forms of stapsdt note args Alan Maguire ` (2 subsequent siblings) 6 siblings, 0 replies; 12+ messages in thread From: Alan Maguire @ 2025-07-28 16:36 UTC (permalink / raw) To: dtrace; +Cc: dtrace-devel, Alan Maguire To ensure stapsdt notes are found/fire for shared libraries, create a shared library and trace the stapsdt probes in it. To ensure the library is loaded when DTrace has started, call it early in the program lifetime and sleep until DTrace starts; at that point trace the probes with the pid and ensure they fire with expected args. Signed-off-by: Alan Maguire <alan.maguire@oracle.com> --- test/unittest/usdt/tst.stapsdt-notes-lib.r | 14 ++ test/unittest/usdt/tst.stapsdt-notes-lib.sh | 145 ++++++++++++++++++++ 2 files changed, 159 insertions(+) create mode 100644 test/unittest/usdt/tst.stapsdt-notes-lib.r create mode 100755 test/unittest/usdt/tst.stapsdt-notes-lib.sh diff --git a/test/unittest/usdt/tst.stapsdt-notes-lib.r b/test/unittest/usdt/tst.stapsdt-notes-lib.r new file mode 100644 index 00000000..7c667a4d --- /dev/null +++ b/test/unittest/usdt/tst.stapsdt-notes-lib.r @@ -0,0 +1,14 @@ +libstapsdttest.so:libfn:zero +libstapsdttest.so:libfn:one:1 +libstapsdttest.so:libfn:two:2:3 +libstapsdttest.so:libfn:three:4:5:7 +libstapsdttest.so:libfn:four:7:8:9:10 +libstapsdttest.so:libfn:five:11:12:13:14:15 +libstapsdttest.so:libfn:six:16:17:18:19:20:21 +libstapsdttest.so:libfn:seven:22:23:24:25:26:27:28 +libstapsdttest.so:libfn:eight:29:30:31:32:33:34:35:36 +libstapsdttest.so:libfn:nine:37:38:39:40:41:42:43:44:45 +libstapsdttest.so:libfn:ten:46:47:48:49:50:51:52:53:54:55 +libstapsdttest.so:libfn:eleven:56:57:58:59:60:61:62:63:64:65 +libstapsdttest.so:libfn:twelve:67:68:69:70:71:72:73:74:75:76 + diff --git a/test/unittest/usdt/tst.stapsdt-notes-lib.sh b/test/unittest/usdt/tst.stapsdt-notes-lib.sh new file mode 100755 index 00000000..6fd5808e --- /dev/null +++ b/test/unittest/usdt/tst.stapsdt-notes-lib.sh @@ -0,0 +1,145 @@ +#!/bin/bash +# +# Oracle Linux DTrace. +# Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. +# Licensed under the Universal Permissive License v 1.0 as shown at +# http://oss.oracle.com/licenses/upl. + +# This test covers all stapsdt probes fired by the STAP_PROBEn macros. +# Arguments values are checked only for first 10 arguments because +# there is support for arg0 ... arg9 only at this moment. + +if [ $# != 1 ]; then + echo expected one argument: '<'dtrace-path'>' + exit 2 +fi + +dtrace=$1 +CC=/usr/bin/gcc +CFLAGS="-I${PWD}/test/unittest/usdt" + +DIRNAME="$tmpdir/usdt-notes.$$.$RANDOM" +mkdir -p $DIRNAME +cd $DIRNAME + +cat > libstapsdttest.c <<EOF +#include <sdt_notes.h> + +void +libfn(int argc, char **argv) +{ + if (argc == 0 && argv == 0) + return; + STAP_PROBE(test_prov, zero); + STAP_PROBE1(test_prov, one, argc); + STAP_PROBE2(test_prov, two, 2, 3); + STAP_PROBE3(test_prov, three, 4, 5, 7); + STAP_PROBE4(test_prov, four, 7, 8, 9, 10); + STAP_PROBE5(test_prov, five, 11, 12, 13, 14, 15); + STAP_PROBE6(test_prov, six, 16, 17, 18, 19, 20, 21); + STAP_PROBE7(test_prov, seven, 22, 23, 24, 25, 26, 27, 28); + STAP_PROBE8(test_prov, eight, 29, 30, 31, 32, 33, 34, 35, 36); + STAP_PROBE9(test_prov, nine, 37, 38, 39, 40, 41, 42, 43, 44, 45); + STAP_PROBE10(test_prov, ten, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55); + STAP_PROBE11(test_prov, eleven, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66); + STAP_PROBE12(test_prov, twelve, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78); +} +EOF + +cat > test.c <<EOF + +#include <unistd.h> + +extern void libfn(int argc, char **argv); + +int +main(int argc, char **argv) +{ + libfn(0, 0); + sleep(10); + libfn(argc, argv); + return 0; +} +EOF + +${CC} ${CFLAGS} -c -fpic libstapsdttest.c +${CC} -shared -o libstapsdttest.so libstapsdttest.o +${CC} -L. ${CFLAGS} -o test test.c -lstapsdttest +if [ $? -ne 0 ]; then + echo "failed to compile test.c" >& 2 + exit 1 +fi + +export LD_LIBRARY_PATH=.:${LD_LIBRARY_PATH} +LD_LIBRARY_PATH=.:${LD_LIBRARY_PATH} ./test & +PID=$! +sleep 5 +$dtrace -p $PID -qs /dev/stdin <<EOF +test_prov\$target:::zero +{ + printf("%s:%s:%s\n", probemod, probefunc, probename); +} + +test_prov\$target:::one +{ + printf("%s:%s:%s:%li\n", probemod, probefunc, probename, arg0); +} + +test_prov\$target:::two +{ + printf("%s:%s:%s:%li:%li\n", probemod, probefunc, probename, arg0, arg1); +} + +test_prov\$target:::three +{ + printf("%s:%s:%s:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, + arg2); +} + +test_prov\$target:::four +{ + printf("%s:%s:%s:%li:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, + arg2, arg3); +} + +test_prov\$target:::five +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4); +} + +test_prov\$target:::six +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5); +} + +test_prov\$target:::seven +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6); +} + +test_prov\$target:::eight +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); +} + +test_prov\$target:::nine +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); +} + +test_prov\$target:::ten, +test_prov\$target:::eleven, +test_prov\$target:::twelve +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); +} +EOF +status=$? + +exit $status -- 2.39.3 ^ permalink raw reply related [flat|nested] 12+ messages in thread
* [PATCH v6 5/7] selftests/usdt: add test covering different forms of stapsdt note args 2025-07-28 16:36 [PATCH v6 0/7] add support for stapsdt probes Alan Maguire ` (3 preceding siblings ...) 2025-07-28 16:36 ` [PATCH v6 4/7] selftests/usdt: add test for stapsdt notes in shared library Alan Maguire @ 2025-07-28 16:36 ` Alan Maguire 2025-07-28 16:36 ` [PATCH v6 6/7] selftests/usdt: add test for stapsdt note-defined probe firing in -fPIE binary Alan Maguire 2025-07-28 16:36 ` [PATCH v6 7/7] selftests/usdt: add is-enabled stapsdt tests using semaphores Alan Maguire 6 siblings, 0 replies; 12+ messages in thread From: Alan Maguire @ 2025-07-28 16:36 UTC (permalink / raw) To: dtrace; +Cc: dtrace-devel, Alan Maguire Add a test exercising various arg types supported by stapsdt notes; register values, register + offset and constants. The test generates a binary with probes represented as follows on x86_64: Displaying notes found in: .note.stapsdt Owner Data size Description stapsdt 0x00000048 NT_STAPSDT (SystemTap probe descriptors) Provider: test_prov Name: args Location: 0x0000000000400557, Base: 0x00000000004005f8, Semaphore: 0x0000000000000000 Arguments: -4@-4(%rbp) 8@%rax 8@%rdx -4@$18 Verify we get expected data for the probe arguments. Signed-off-by: Alan Maguire <alan.maguire@oracle.com> --- test/unittest/usdt/tst.stapsdt-notes-args.r | 2 + test/unittest/usdt/tst.stapsdt-notes-args.sh | 50 ++++++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 test/unittest/usdt/tst.stapsdt-notes-args.r create mode 100755 test/unittest/usdt/tst.stapsdt-notes-args.sh diff --git a/test/unittest/usdt/tst.stapsdt-notes-args.r b/test/unittest/usdt/tst.stapsdt-notes-args.r new file mode 100644 index 00000000..42bca19f --- /dev/null +++ b/test/unittest/usdt/tst.stapsdt-notes-args.r @@ -0,0 +1,2 @@ +test:main:args:2:./test:val:18 + diff --git a/test/unittest/usdt/tst.stapsdt-notes-args.sh b/test/unittest/usdt/tst.stapsdt-notes-args.sh new file mode 100755 index 00000000..82097808 --- /dev/null +++ b/test/unittest/usdt/tst.stapsdt-notes-args.sh @@ -0,0 +1,50 @@ +#!/bin/bash +# +# Oracle Linux DTrace. +# Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. +# Licensed under the Universal Permissive License v 1.0 as shown at +# http://oss.oracle.com/licenses/upl. + +# This test covers stapsdt probes fired by the STAP_PROBEn macros, +# testing various argument forms (constant, register, deref etc). + +if [ $# != 1 ]; then + echo expected one argument: '<'dtrace-path'>' + exit 2 +fi + +dtrace=$1 +CC=/usr/bin/gcc +CFLAGS="-I${PWD}/test/unittest/usdt" + +DIRNAME="$tmpdir/usdt-notes.$$.$RANDOM" +mkdir -p $DIRNAME +cd $DIRNAME + +cat > test.c <<EOF +#include <sdt_notes.h> + +int +main(int argc, char **argv) +{ + STAP_PROBE4(test_prov, args, argc, argv[0], argv[1] + 4, 18); +} +EOF + +${CC} ${CFLAGS} -o test test.c +if [ $? -ne 0 ]; then + echo "failed to compile test.c" >& 2 + exit 1 +fi + +$dtrace -c './test arg1val' -qs /dev/stdin <<EOF +test_prov\$target:::args +{ + printf("%s:%s:%s:%li:%s:%s:%li\n", probemod, probefunc, probename, + arg0, copyinstr(arg1), copyinstr(arg2), arg3); +} + +EOF +status=$? + +exit $status -- 2.39.3 ^ permalink raw reply related [flat|nested] 12+ messages in thread
* [PATCH v6 6/7] selftests/usdt: add test for stapsdt note-defined probe firing in -fPIE binary 2025-07-28 16:36 [PATCH v6 0/7] add support for stapsdt probes Alan Maguire ` (4 preceding siblings ...) 2025-07-28 16:36 ` [PATCH v6 5/7] selftests/usdt: add test covering different forms of stapsdt note args Alan Maguire @ 2025-07-28 16:36 ` Alan Maguire 2025-07-28 16:36 ` [PATCH v6 7/7] selftests/usdt: add is-enabled stapsdt tests using semaphores Alan Maguire 6 siblings, 0 replies; 12+ messages in thread From: Alan Maguire @ 2025-07-28 16:36 UTC (permalink / raw) To: dtrace; +Cc: dtrace-devel, Alan Maguire Add test identical to the binary test ensuring that -fPIE is specified in CFLAGS; this verifies that compilers that use such flags by default (as is the case for Debian) can instrument stapsdt notes. Signed-off-by: Alan Maguire <alan.maguire@oracle.com> --- test/unittest/usdt/tst.stapsdt-notes-pie.sh | 121 ++++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100755 test/unittest/usdt/tst.stapsdt-notes-pie.sh diff --git a/test/unittest/usdt/tst.stapsdt-notes-pie.sh b/test/unittest/usdt/tst.stapsdt-notes-pie.sh new file mode 100755 index 00000000..08ee06da --- /dev/null +++ b/test/unittest/usdt/tst.stapsdt-notes-pie.sh @@ -0,0 +1,121 @@ +#!/bin/bash +# +# Oracle Linux DTrace. +# Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. +# Licensed under the Universal Permissive License v 1.0 as shown at +# http://oss.oracle.com/licenses/upl. + +# This test covers all stapsdt probes fired by the STAP_PROBEn macros. +# Arguments values are checked only for first 10 arguments because +# there is support for arg0 ... arg9 only at this moment. + +if [ $# != 1 ]; then + echo expected one argument: '<'dtrace-path'>' + exit 2 +fi + +dtrace=$1 +CC=/usr/bin/gcc +CFLAGS="-fPIE -I${PWD}/test/unittest/usdt" + +DIRNAME="$tmpdir/usdt-notes.$$.$RANDOM" +mkdir -p $DIRNAME +cd $DIRNAME + +cat > test.c <<EOF +#include <sdt_notes.h> + +int +main(int argc, char **argv) +{ + STAP_PROBE(test_prov, zero); + STAP_PROBE1(test_prov, one, argc); + STAP_PROBE2(test_prov, two, 2, 3); + STAP_PROBE3(test_prov, three, 4, 5, 7); + STAP_PROBE4(test_prov, four, 7, 8, 9, 10); + STAP_PROBE5(test_prov, five, 11, 12, 13, 14, 15); + STAP_PROBE6(test_prov, six, 16, 17, 18, 19, 20, 21); + STAP_PROBE7(test_prov, seven, 22, 23, 24, 25, 26, 27, 28); + STAP_PROBE8(test_prov, eight, 29, 30, 31, 32, 33, 34, 35, 36); + STAP_PROBE9(test_prov, nine, 37, 38, 39, 40, 41, 42, 43, 44, 45); + STAP_PROBE10(test_prov, ten, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55); + STAP_PROBE11(test_prov, eleven, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66); + STAP_PROBE12(test_prov, twelve, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78); +} +EOF + +${CC} ${CFLAGS} -o test test.c +if [ $? -ne 0 ]; then + echo "failed to compile test.c" >& 2 + exit 1 +fi + +$dtrace -c ./test -qs /dev/stdin <<EOF +test_prov\$target:::zero +{ + printf("%s:%s:%s\n", probemod, probefunc, probename); +} + +test_prov\$target:::one +{ + printf("%s:%s:%s:%li\n", probemod, probefunc, probename, arg0); +} + +test_prov\$target:::two +{ + printf("%s:%s:%s:%li:%li\n", probemod, probefunc, probename, arg0, arg1); +} + +test_prov\$target:::three +{ + printf("%s:%s:%s:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, + arg2); +} + +test_prov\$target:::four +{ + printf("%s:%s:%s:%li:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, + arg2, arg3); +} + +test_prov\$target:::five +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4); +} + +test_prov\$target:::six +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5); +} + +test_prov\$target:::seven +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6); +} + +test_prov\$target:::eight +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); +} + +test_prov\$target:::nine +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); +} + +test_prov\$target:::ten, +test_prov\$target:::eleven, +test_prov\$target:::twelve +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); +} +EOF +status=$? + +exit $status -- 2.39.3 ^ permalink raw reply related [flat|nested] 12+ messages in thread
* [PATCH v6 7/7] selftests/usdt: add is-enabled stapsdt tests using semaphores 2025-07-28 16:36 [PATCH v6 0/7] add support for stapsdt probes Alan Maguire ` (5 preceding siblings ...) 2025-07-28 16:36 ` [PATCH v6 6/7] selftests/usdt: add test for stapsdt note-defined probe firing in -fPIE binary Alan Maguire @ 2025-07-28 16:36 ` Alan Maguire 2025-07-29 2:07 ` Kris Van Hees 6 siblings, 1 reply; 12+ messages in thread From: Alan Maguire @ 2025-07-28 16:36 UTC (permalink / raw) To: dtrace; +Cc: dtrace-devel, Alan Maguire Is-eanbled probes are implemented using semaphores where the semaphore address is specified in the ELF notes and passed in at probe creation time to have the kernel reference-count probes; this allows us to have argument assembly code that only gets executed when the stapsdt probe is in use. Signed-off-by: Alan Maguire <alan.maguire@oracle.com> --- .../usdt/tst.stapsdt-notes-isenabled.r | 14 ++ .../usdt/tst.stapsdt-notes-isenabled.sh | 151 ++++++++++++++++++ 2 files changed, 165 insertions(+) create mode 100644 test/unittest/usdt/tst.stapsdt-notes-isenabled.r create mode 100755 test/unittest/usdt/tst.stapsdt-notes-isenabled.sh diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.r b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r new file mode 100644 index 00000000..db6d18cb --- /dev/null +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r @@ -0,0 +1,14 @@ +test:main:zero +test:main:one:1 +test:main:two:2:3 +test:main:three:4:5:7 +test:main:four:7:8:9:10 +test:main:five:11:12:13:14:15 +test:main:six:16:17:18:19:20:21 +test:main:seven:22:23:24:25:26:27:28 +test:main:eight:29:30:31:32:33:34:35:36 +test:main:nine:37:38:39:40:41:42:43:44:45 +test:main:ten:46:47:48:49:50:51:52:53:54:55 +test:main:eleven:56:57:58:59:60:61:62:63:64:65 +test:main:twelve:67:68:69:70:71:72:73:74:75:76 + diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh new file mode 100755 index 00000000..99fcc844 --- /dev/null +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh @@ -0,0 +1,151 @@ +#!/bin/bash +# +# Oracle Linux DTrace. +# Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. +# Licensed under the Universal Permissive License v 1.0 as shown at +# http://oss.oracle.com/licenses/upl. + +# This test covers all stapsdt probes fired by the STAP_PROBEn macros. +# Arguments values are checked only for first 10 arguments because +# there is support for arg0 ... arg9 only at this moment. + +if [ $# != 1 ]; then + echo expected one argument: '<'dtrace-path'>' + exit 2 +fi + +dtrace=$1 +CC=/usr/bin/gcc +CFLAGS="-I${PWD}/test/unittest/usdt" + +DIRNAME="$tmpdir/usdt-notes.$$.$RANDOM" +mkdir -p $DIRNAME +cd $DIRNAME + +cat > test.c <<EOF +#define _SDT_HAS_SEMAPHORES 1 +#include <sdt_notes.h> + +#define SEC(name) __attribute__((section(name), used)) + +unsigned short test_prov_zero_semaphore SEC(".probes"); +unsigned short test_prov_one_semaphore SEC(".probes"); +unsigned short test_prov_two_semaphore SEC(".probes"); +unsigned short test_prov_three_semaphore SEC(".probes"); +unsigned short test_prov_four_semaphore SEC(".probes"); +unsigned short test_prov_five_semaphore SEC(".probes"); +unsigned short test_prov_six_semaphore SEC(".probes"); +unsigned short test_prov_seven_semaphore SEC(".probes"); +unsigned short test_prov_eight_semaphore SEC(".probes"); +unsigned short test_prov_nine_semaphore SEC(".probes"); +unsigned short test_prov_ten_semaphore SEC(".probes"); +unsigned short test_prov_eleven_semaphore SEC(".probes"); +unsigned short test_prov_twelve_semaphore SEC(".probes"); + +int +main(int argc, char **argv) +{ + if (test_prov_zero_semaphore) + STAP_PROBE(test_prov, zero); + if (test_prov_one_semaphore) + STAP_PROBE1(test_prov, one, argc); + if (test_prov_two_semaphore) + STAP_PROBE2(test_prov, two, 2, 3); + if (test_prov_three_semaphore) + STAP_PROBE3(test_prov, three, 4, 5, 7); + if (test_prov_four_semaphore) + STAP_PROBE4(test_prov, four, 7, 8, 9, 10); + if (test_prov_five_semaphore) + STAP_PROBE5(test_prov, five, 11, 12, 13, 14, 15); + if (test_prov_six_semaphore) + STAP_PROBE6(test_prov, six, 16, 17, 18, 19, 20, 21); + if (test_prov_seven_semaphore) + STAP_PROBE7(test_prov, seven, 22, 23, 24, 25, 26, 27, 28); + if (test_prov_eight_semaphore) + STAP_PROBE8(test_prov, eight, 29, 30, 31, 32, 33, 34, 35, 36); + if (test_prov_nine_semaphore) + STAP_PROBE9(test_prov, nine, 37, 38, 39, 40, 41, 42, 43, 44, 45); + if (test_prov_ten_semaphore) + STAP_PROBE10(test_prov, ten, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55); + if (test_prov_eleven_semaphore) + STAP_PROBE11(test_prov, eleven, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66); + if (test_prov_twelve_semaphore) + STAP_PROBE12(test_prov, twelve, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78); +} +EOF + +${CC} ${CFLAGS} -o test test.c +if [ $? -ne 0 ]; then + echo "failed to compile test.c" >& 2 + exit 1 +fi + +$dtrace -c ./test -qs /dev/stdin <<EOF +test_prov\$target:::zero +{ + printf("%s:%s:%s\n", probemod, probefunc, probename); +} + +test_prov\$target:::one +{ + printf("%s:%s:%s:%li\n", probemod, probefunc, probename, arg0); +} + +test_prov\$target:::two +{ + printf("%s:%s:%s:%li:%li\n", probemod, probefunc, probename, arg0, arg1); +} + +test_prov\$target:::three +{ + printf("%s:%s:%s:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, + arg2); +} + +test_prov\$target:::four +{ + printf("%s:%s:%s:%li:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, + arg2, arg3); +} + +test_prov\$target:::five +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4); +} + +test_prov\$target:::six +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5); +} + +test_prov\$target:::seven +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6); +} + +test_prov\$target:::eight +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); +} + +test_prov\$target:::nine +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); +} + +test_prov\$target:::ten, +test_prov\$target:::eleven, +test_prov\$target:::twelve +{ + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); +} +EOF +status=$? + +exit $status -- 2.39.3 ^ permalink raw reply related [flat|nested] 12+ messages in thread
* Re: [PATCH v6 7/7] selftests/usdt: add is-enabled stapsdt tests using semaphores 2025-07-28 16:36 ` [PATCH v6 7/7] selftests/usdt: add is-enabled stapsdt tests using semaphores Alan Maguire @ 2025-07-29 2:07 ` Kris Van Hees 2025-07-29 7:37 ` Alan Maguire 0 siblings, 1 reply; 12+ messages in thread From: Kris Van Hees @ 2025-07-29 2:07 UTC (permalink / raw) To: Alan Maguire; +Cc: dtrace, dtrace-devel This test is flawed because you never initialize the semaphores. If you change the code to assign 0 to then, then the test fails because the probes never fire. That makes sense because your implementation does not actually do anything with the semaphore, i.e. if the probe it relatees to is enabled, nothing happens to the semaphore, so while you do store the address of the semaphore in patch 2, it is never used for anything, so this test passing is actually accidental because the semaphore initial value is (apparently) most commonly *not* 0. On Mon, Jul 28, 2025 at 05:36:11PM +0100, Alan Maguire wrote: > Is-eanbled probes are implemented using semaphores where the > semaphore address is specified in the ELF notes and passed > in at probe creation time to have the kernel reference-count > probes; this allows us to have argument assembly code that > only gets executed when the stapsdt probe is in use. > > Signed-off-by: Alan Maguire <alan.maguire@oracle.com> > --- > .../usdt/tst.stapsdt-notes-isenabled.r | 14 ++ > .../usdt/tst.stapsdt-notes-isenabled.sh | 151 ++++++++++++++++++ > 2 files changed, 165 insertions(+) > create mode 100644 test/unittest/usdt/tst.stapsdt-notes-isenabled.r > create mode 100755 test/unittest/usdt/tst.stapsdt-notes-isenabled.sh > > diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.r b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r > new file mode 100644 > index 00000000..db6d18cb > --- /dev/null > +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r > @@ -0,0 +1,14 @@ > +test:main:zero > +test:main:one:1 > +test:main:two:2:3 > +test:main:three:4:5:7 > +test:main:four:7:8:9:10 > +test:main:five:11:12:13:14:15 > +test:main:six:16:17:18:19:20:21 > +test:main:seven:22:23:24:25:26:27:28 > +test:main:eight:29:30:31:32:33:34:35:36 > +test:main:nine:37:38:39:40:41:42:43:44:45 > +test:main:ten:46:47:48:49:50:51:52:53:54:55 > +test:main:eleven:56:57:58:59:60:61:62:63:64:65 > +test:main:twelve:67:68:69:70:71:72:73:74:75:76 > + > diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh > new file mode 100755 > index 00000000..99fcc844 > --- /dev/null > +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh > @@ -0,0 +1,151 @@ > +#!/bin/bash > +# > +# Oracle Linux DTrace. > +# Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. > +# Licensed under the Universal Permissive License v 1.0 as shown at > +# http://oss.oracle.com/licenses/upl. > + > +# This test covers all stapsdt probes fired by the STAP_PROBEn macros. > +# Arguments values are checked only for first 10 arguments because > +# there is support for arg0 ... arg9 only at this moment. > + > +if [ $# != 1 ]; then > + echo expected one argument: '<'dtrace-path'>' > + exit 2 > +fi > + > +dtrace=$1 > +CC=/usr/bin/gcc > +CFLAGS="-I${PWD}/test/unittest/usdt" > + > +DIRNAME="$tmpdir/usdt-notes.$$.$RANDOM" > +mkdir -p $DIRNAME > +cd $DIRNAME > + > +cat > test.c <<EOF > +#define _SDT_HAS_SEMAPHORES 1 > +#include <sdt_notes.h> > + > +#define SEC(name) __attribute__((section(name), used)) > + > +unsigned short test_prov_zero_semaphore SEC(".probes"); > +unsigned short test_prov_one_semaphore SEC(".probes"); > +unsigned short test_prov_two_semaphore SEC(".probes"); > +unsigned short test_prov_three_semaphore SEC(".probes"); > +unsigned short test_prov_four_semaphore SEC(".probes"); > +unsigned short test_prov_five_semaphore SEC(".probes"); > +unsigned short test_prov_six_semaphore SEC(".probes"); > +unsigned short test_prov_seven_semaphore SEC(".probes"); > +unsigned short test_prov_eight_semaphore SEC(".probes"); > +unsigned short test_prov_nine_semaphore SEC(".probes"); > +unsigned short test_prov_ten_semaphore SEC(".probes"); > +unsigned short test_prov_eleven_semaphore SEC(".probes"); > +unsigned short test_prov_twelve_semaphore SEC(".probes"); > + > +int > +main(int argc, char **argv) > +{ > + if (test_prov_zero_semaphore) > + STAP_PROBE(test_prov, zero); > + if (test_prov_one_semaphore) > + STAP_PROBE1(test_prov, one, argc); > + if (test_prov_two_semaphore) > + STAP_PROBE2(test_prov, two, 2, 3); > + if (test_prov_three_semaphore) > + STAP_PROBE3(test_prov, three, 4, 5, 7); > + if (test_prov_four_semaphore) > + STAP_PROBE4(test_prov, four, 7, 8, 9, 10); > + if (test_prov_five_semaphore) > + STAP_PROBE5(test_prov, five, 11, 12, 13, 14, 15); > + if (test_prov_six_semaphore) > + STAP_PROBE6(test_prov, six, 16, 17, 18, 19, 20, 21); > + if (test_prov_seven_semaphore) > + STAP_PROBE7(test_prov, seven, 22, 23, 24, 25, 26, 27, 28); > + if (test_prov_eight_semaphore) > + STAP_PROBE8(test_prov, eight, 29, 30, 31, 32, 33, 34, 35, 36); > + if (test_prov_nine_semaphore) > + STAP_PROBE9(test_prov, nine, 37, 38, 39, 40, 41, 42, 43, 44, 45); > + if (test_prov_ten_semaphore) > + STAP_PROBE10(test_prov, ten, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55); > + if (test_prov_eleven_semaphore) > + STAP_PROBE11(test_prov, eleven, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66); > + if (test_prov_twelve_semaphore) > + STAP_PROBE12(test_prov, twelve, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78); > +} > +EOF > + > +${CC} ${CFLAGS} -o test test.c > +if [ $? -ne 0 ]; then > + echo "failed to compile test.c" >& 2 > + exit 1 > +fi > + > +$dtrace -c ./test -qs /dev/stdin <<EOF > +test_prov\$target:::zero > +{ > + printf("%s:%s:%s\n", probemod, probefunc, probename); > +} > + > +test_prov\$target:::one > +{ > + printf("%s:%s:%s:%li\n", probemod, probefunc, probename, arg0); > +} > + > +test_prov\$target:::two > +{ > + printf("%s:%s:%s:%li:%li\n", probemod, probefunc, probename, arg0, arg1); > +} > + > +test_prov\$target:::three > +{ > + printf("%s:%s:%s:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, > + arg2); > +} > + > +test_prov\$target:::four > +{ > + printf("%s:%s:%s:%li:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, > + arg2, arg3); > +} > + > +test_prov\$target:::five > +{ > + printf("%s:%s:%s:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > + arg0, arg1, arg2, arg3, arg4); > +} > + > +test_prov\$target:::six > +{ > + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > + arg0, arg1, arg2, arg3, arg4, arg5); > +} > + > +test_prov\$target:::seven > +{ > + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > + arg0, arg1, arg2, arg3, arg4, arg5, arg6); > +} > + > +test_prov\$target:::eight > +{ > + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); > +} > + > +test_prov\$target:::nine > +{ > + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); > +} > + > +test_prov\$target:::ten, > +test_prov\$target:::eleven, > +test_prov\$target:::twelve > +{ > + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); > +} > +EOF > +status=$? > + > +exit $status > -- > 2.39.3 > ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [PATCH v6 7/7] selftests/usdt: add is-enabled stapsdt tests using semaphores 2025-07-29 2:07 ` Kris Van Hees @ 2025-07-29 7:37 ` Alan Maguire 2025-07-29 11:49 ` Kris Van Hees 0 siblings, 1 reply; 12+ messages in thread From: Alan Maguire @ 2025-07-29 7:37 UTC (permalink / raw) To: Kris Van Hees; +Cc: dtrace, dtrace-devel On 29/07/2025 03:07, Kris Van Hees wrote: > This test is flawed because you never initialize the semaphores. If you change > the code to assign 0 to then, then the test fails because the probes never > fire. That makes sense because your implementation does not actually do Hmm, I don't see this behaviour. If I change the semaphores to be set to 0, i.e. -unsigned short test_prov_zero_semaphore SEC(".probes"); -unsigned short test_prov_one_semaphore SEC(".probes"); -unsigned short test_prov_two_semaphore SEC(".probes"); -unsigned short test_prov_three_semaphore SEC(".probes"); -unsigned short test_prov_four_semaphore SEC(".probes"); -unsigned short test_prov_five_semaphore SEC(".probes"); -unsigned short test_prov_six_semaphore SEC(".probes"); -unsigned short test_prov_seven_semaphore SEC(".probes"); -unsigned short test_prov_eight_semaphore SEC(".probes"); -unsigned short test_prov_nine_semaphore SEC(".probes"); -unsigned short test_prov_ten_semaphore SEC(".probes"); -unsigned short test_prov_eleven_semaphore SEC(".probes"); -unsigned short test_prov_twelve_semaphore SEC(".probes"); +unsigned short test_prov_zero_semaphore SEC(".probes") = 0; +unsigned short test_prov_one_semaphore SEC(".probes") = 0; +unsigned short test_prov_two_semaphore SEC(".probes") = 0; +unsigned short test_prov_three_semaphore SEC(".probes") = 0; +unsigned short test_prov_four_semaphore SEC(".probes") = 0; +unsigned short test_prov_five_semaphore SEC(".probes") = 0; +unsigned short test_prov_six_semaphore SEC(".probes") = 0; +unsigned short test_prov_seven_semaphore SEC(".probes") = 0; +unsigned short test_prov_eight_semaphore SEC(".probes") = 0; +unsigned short test_prov_nine_semaphore SEC(".probes") = 0; +unsigned short test_prov_ten_semaphore SEC(".probes") = 0; +unsigned short test_prov_eleven_semaphore SEC(".probes") = 0; +unsigned short test_prov_twelve_semaphore SEC(".probes") = 0; ...the test still passes. Are you perhaps initializing the semaphores in main()? This has the potential to overwrite the kernel-updated values which are incremented when the probes are enabled. > anything with the semaphore, i.e. if the probe it relatees to is enabled, > nothing happens to the semaphore, so while you do store the address of the > semaphore in patch 2, it is never used for anything, so this test passing is The refcntr address is set in parentheses where the probe is set up - see uprobe_create(): if (refcntr_off) { if (asprintf(&spec, "%s:0x%lx(0x%lx)", mapping_fn, addr, refcntr_off) < 0) return NULL; } else { if (asprintf(&spec, "%s:0x%lx", mapping_fn, addr) < 0) return NULL; } The parenthesized value is then handed off to the kernel to reference-count probe enablings. > actually accidental because the semaphore initial value is (apparently) most > commonly *not* 0. > > On Mon, Jul 28, 2025 at 05:36:11PM +0100, Alan Maguire wrote: >> Is-eanbled probes are implemented using semaphores where the >> semaphore address is specified in the ELF notes and passed >> in at probe creation time to have the kernel reference-count >> probes; this allows us to have argument assembly code that >> only gets executed when the stapsdt probe is in use. >> >> Signed-off-by: Alan Maguire <alan.maguire@oracle.com> >> --- >> .../usdt/tst.stapsdt-notes-isenabled.r | 14 ++ >> .../usdt/tst.stapsdt-notes-isenabled.sh | 151 ++++++++++++++++++ >> 2 files changed, 165 insertions(+) >> create mode 100644 test/unittest/usdt/tst.stapsdt-notes-isenabled.r >> create mode 100755 test/unittest/usdt/tst.stapsdt-notes-isenabled.sh >> >> diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.r b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r >> new file mode 100644 >> index 00000000..db6d18cb >> --- /dev/null >> +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r >> @@ -0,0 +1,14 @@ >> +test:main:zero >> +test:main:one:1 >> +test:main:two:2:3 >> +test:main:three:4:5:7 >> +test:main:four:7:8:9:10 >> +test:main:five:11:12:13:14:15 >> +test:main:six:16:17:18:19:20:21 >> +test:main:seven:22:23:24:25:26:27:28 >> +test:main:eight:29:30:31:32:33:34:35:36 >> +test:main:nine:37:38:39:40:41:42:43:44:45 >> +test:main:ten:46:47:48:49:50:51:52:53:54:55 >> +test:main:eleven:56:57:58:59:60:61:62:63:64:65 >> +test:main:twelve:67:68:69:70:71:72:73:74:75:76 >> + >> diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh >> new file mode 100755 >> index 00000000..99fcc844 >> --- /dev/null >> +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh >> @@ -0,0 +1,151 @@ >> +#!/bin/bash >> +# >> +# Oracle Linux DTrace. >> +# Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. >> +# Licensed under the Universal Permissive License v 1.0 as shown at >> +# http://oss.oracle.com/licenses/upl. >> + >> +# This test covers all stapsdt probes fired by the STAP_PROBEn macros. >> +# Arguments values are checked only for first 10 arguments because >> +# there is support for arg0 ... arg9 only at this moment. >> + >> +if [ $# != 1 ]; then >> + echo expected one argument: '<'dtrace-path'>' >> + exit 2 >> +fi >> + >> +dtrace=$1 >> +CC=/usr/bin/gcc >> +CFLAGS="-I${PWD}/test/unittest/usdt" >> + >> +DIRNAME="$tmpdir/usdt-notes.$$.$RANDOM" >> +mkdir -p $DIRNAME >> +cd $DIRNAME >> + >> +cat > test.c <<EOF >> +#define _SDT_HAS_SEMAPHORES 1 >> +#include <sdt_notes.h> >> + >> +#define SEC(name) __attribute__((section(name), used)) >> + >> +unsigned short test_prov_zero_semaphore SEC(".probes"); >> +unsigned short test_prov_one_semaphore SEC(".probes"); >> +unsigned short test_prov_two_semaphore SEC(".probes"); >> +unsigned short test_prov_three_semaphore SEC(".probes"); >> +unsigned short test_prov_four_semaphore SEC(".probes"); >> +unsigned short test_prov_five_semaphore SEC(".probes"); >> +unsigned short test_prov_six_semaphore SEC(".probes"); >> +unsigned short test_prov_seven_semaphore SEC(".probes"); >> +unsigned short test_prov_eight_semaphore SEC(".probes"); >> +unsigned short test_prov_nine_semaphore SEC(".probes"); >> +unsigned short test_prov_ten_semaphore SEC(".probes"); >> +unsigned short test_prov_eleven_semaphore SEC(".probes"); >> +unsigned short test_prov_twelve_semaphore SEC(".probes"); >> + >> +int >> +main(int argc, char **argv) >> +{ >> + if (test_prov_zero_semaphore) >> + STAP_PROBE(test_prov, zero); >> + if (test_prov_one_semaphore) >> + STAP_PROBE1(test_prov, one, argc); >> + if (test_prov_two_semaphore) >> + STAP_PROBE2(test_prov, two, 2, 3); >> + if (test_prov_three_semaphore) >> + STAP_PROBE3(test_prov, three, 4, 5, 7); >> + if (test_prov_four_semaphore) >> + STAP_PROBE4(test_prov, four, 7, 8, 9, 10); >> + if (test_prov_five_semaphore) >> + STAP_PROBE5(test_prov, five, 11, 12, 13, 14, 15); >> + if (test_prov_six_semaphore) >> + STAP_PROBE6(test_prov, six, 16, 17, 18, 19, 20, 21); >> + if (test_prov_seven_semaphore) >> + STAP_PROBE7(test_prov, seven, 22, 23, 24, 25, 26, 27, 28); >> + if (test_prov_eight_semaphore) >> + STAP_PROBE8(test_prov, eight, 29, 30, 31, 32, 33, 34, 35, 36); >> + if (test_prov_nine_semaphore) >> + STAP_PROBE9(test_prov, nine, 37, 38, 39, 40, 41, 42, 43, 44, 45); >> + if (test_prov_ten_semaphore) >> + STAP_PROBE10(test_prov, ten, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55); >> + if (test_prov_eleven_semaphore) >> + STAP_PROBE11(test_prov, eleven, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66); >> + if (test_prov_twelve_semaphore) >> + STAP_PROBE12(test_prov, twelve, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78); >> +} >> +EOF >> + >> +${CC} ${CFLAGS} -o test test.c >> +if [ $? -ne 0 ]; then >> + echo "failed to compile test.c" >& 2 >> + exit 1 >> +fi >> + >> +$dtrace -c ./test -qs /dev/stdin <<EOF >> +test_prov\$target:::zero >> +{ >> + printf("%s:%s:%s\n", probemod, probefunc, probename); >> +} >> + >> +test_prov\$target:::one >> +{ >> + printf("%s:%s:%s:%li\n", probemod, probefunc, probename, arg0); >> +} >> + >> +test_prov\$target:::two >> +{ >> + printf("%s:%s:%s:%li:%li\n", probemod, probefunc, probename, arg0, arg1); >> +} >> + >> +test_prov\$target:::three >> +{ >> + printf("%s:%s:%s:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, >> + arg2); >> +} >> + >> +test_prov\$target:::four >> +{ >> + printf("%s:%s:%s:%li:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, >> + arg2, arg3); >> +} >> + >> +test_prov\$target:::five >> +{ >> + printf("%s:%s:%s:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >> + arg0, arg1, arg2, arg3, arg4); >> +} >> + >> +test_prov\$target:::six >> +{ >> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >> + arg0, arg1, arg2, arg3, arg4, arg5); >> +} >> + >> +test_prov\$target:::seven >> +{ >> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >> + arg0, arg1, arg2, arg3, arg4, arg5, arg6); >> +} >> + >> +test_prov\$target:::eight >> +{ >> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >> + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); >> +} >> + >> +test_prov\$target:::nine >> +{ >> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >> + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); >> +} >> + >> +test_prov\$target:::ten, >> +test_prov\$target:::eleven, >> +test_prov\$target:::twelve >> +{ >> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >> + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); >> +} >> +EOF >> +status=$? >> + >> +exit $status >> -- >> 2.39.3 >> ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [PATCH v6 7/7] selftests/usdt: add is-enabled stapsdt tests using semaphores 2025-07-29 7:37 ` Alan Maguire @ 2025-07-29 11:49 ` Kris Van Hees 2025-07-29 13:16 ` Alan Maguire 0 siblings, 1 reply; 12+ messages in thread From: Kris Van Hees @ 2025-07-29 11:49 UTC (permalink / raw) To: Alan Maguire; +Cc: Kris Van Hees, dtrace, dtrace-devel On Tue, Jul 29, 2025 at 08:37:16AM +0100, Alan Maguire wrote: > On 29/07/2025 03:07, Kris Van Hees wrote: > > This test is flawed because you never initialize the semaphores. If you change > > the code to assign 0 to then, then the test fails because the probes never > > fire. That makes sense because your implementation does not actually do > > Hmm, I don't see this behaviour. If I change the semaphores to be set to > 0, i.e. > > -unsigned short test_prov_zero_semaphore SEC(".probes"); > -unsigned short test_prov_one_semaphore SEC(".probes"); > -unsigned short test_prov_two_semaphore SEC(".probes"); > -unsigned short test_prov_three_semaphore SEC(".probes"); > -unsigned short test_prov_four_semaphore SEC(".probes"); > -unsigned short test_prov_five_semaphore SEC(".probes"); > -unsigned short test_prov_six_semaphore SEC(".probes"); > -unsigned short test_prov_seven_semaphore SEC(".probes"); > -unsigned short test_prov_eight_semaphore SEC(".probes"); > -unsigned short test_prov_nine_semaphore SEC(".probes"); > -unsigned short test_prov_ten_semaphore SEC(".probes"); > -unsigned short test_prov_eleven_semaphore SEC(".probes"); > -unsigned short test_prov_twelve_semaphore SEC(".probes"); > +unsigned short test_prov_zero_semaphore SEC(".probes") = 0; > +unsigned short test_prov_one_semaphore SEC(".probes") = 0; > +unsigned short test_prov_two_semaphore SEC(".probes") = 0; > +unsigned short test_prov_three_semaphore SEC(".probes") = 0; > +unsigned short test_prov_four_semaphore SEC(".probes") = 0; > +unsigned short test_prov_five_semaphore SEC(".probes") = 0; > +unsigned short test_prov_six_semaphore SEC(".probes") = 0; > +unsigned short test_prov_seven_semaphore SEC(".probes") = 0; > +unsigned short test_prov_eight_semaphore SEC(".probes") = 0; > +unsigned short test_prov_nine_semaphore SEC(".probes") = 0; > +unsigned short test_prov_ten_semaphore SEC(".probes") = 0; > +unsigned short test_prov_eleven_semaphore SEC(".probes") = 0; > +unsigned short test_prov_twelve_semaphore SEC(".probes") = 0; > > ...the test still passes. Are you perhaps initializing the semaphores in > main()? This has the potential to overwrite the kernel-updated values > which are incremented when the probes are enabled. I put the assignment before the SEC(...) which may have caused the semaphore to perhaps not be created as expected. Also, do you actually need the SEC(...) for this? From the look of the code in the kernel, any offset in the inode would work, and unnless I overlooked it I also do not see anything in the macros for systemtap that require a specific section for the semaphore variables. > > anything with the semaphore, i.e. if the probe it relatees to is enabled, > > nothing happens to the semaphore, so while you do store the address of the > > semaphore in patch 2, it is never used for anything, so this test passing is > > The refcntr address is set in parentheses where the probe is set up - > see uprobe_create(): > > if (refcntr_off) { > if (asprintf(&spec, "%s:0x%lx(0x%lx)", mapping_fn, addr, > refcntr_off) < 0) > return NULL; > } else { > if (asprintf(&spec, "%s:0x%lx", mapping_fn, addr) < 0) > return NULL; > } > > The parenthesized value is then handed off to the kernel to > reference-count probe enablings. Ah, overlooked that :) My bad. Sorry about the false alarm on that. However, there definitely should be tests that also check that when the probe is *not* enabled, the code is indeed also not executed. > > > actually accidental because the semaphore initial value is (apparently) most > > commonly *not* 0. > > > > On Mon, Jul 28, 2025 at 05:36:11PM +0100, Alan Maguire wrote: > >> Is-eanbled probes are implemented using semaphores where the > >> semaphore address is specified in the ELF notes and passed > >> in at probe creation time to have the kernel reference-count > >> probes; this allows us to have argument assembly code that > >> only gets executed when the stapsdt probe is in use. > >> > >> Signed-off-by: Alan Maguire <alan.maguire@oracle.com> > >> --- > >> .../usdt/tst.stapsdt-notes-isenabled.r | 14 ++ > >> .../usdt/tst.stapsdt-notes-isenabled.sh | 151 ++++++++++++++++++ > >> 2 files changed, 165 insertions(+) > >> create mode 100644 test/unittest/usdt/tst.stapsdt-notes-isenabled.r > >> create mode 100755 test/unittest/usdt/tst.stapsdt-notes-isenabled.sh > >> > >> diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.r b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r > >> new file mode 100644 > >> index 00000000..db6d18cb > >> --- /dev/null > >> +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r > >> @@ -0,0 +1,14 @@ > >> +test:main:zero > >> +test:main:one:1 > >> +test:main:two:2:3 > >> +test:main:three:4:5:7 > >> +test:main:four:7:8:9:10 > >> +test:main:five:11:12:13:14:15 > >> +test:main:six:16:17:18:19:20:21 > >> +test:main:seven:22:23:24:25:26:27:28 > >> +test:main:eight:29:30:31:32:33:34:35:36 > >> +test:main:nine:37:38:39:40:41:42:43:44:45 > >> +test:main:ten:46:47:48:49:50:51:52:53:54:55 > >> +test:main:eleven:56:57:58:59:60:61:62:63:64:65 > >> +test:main:twelve:67:68:69:70:71:72:73:74:75:76 > >> + > >> diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh > >> new file mode 100755 > >> index 00000000..99fcc844 > >> --- /dev/null > >> +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh > >> @@ -0,0 +1,151 @@ > >> +#!/bin/bash > >> +# > >> +# Oracle Linux DTrace. > >> +# Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. > >> +# Licensed under the Universal Permissive License v 1.0 as shown at > >> +# http://oss.oracle.com/licenses/upl. > >> + > >> +# This test covers all stapsdt probes fired by the STAP_PROBEn macros. > >> +# Arguments values are checked only for first 10 arguments because > >> +# there is support for arg0 ... arg9 only at this moment. > >> + > >> +if [ $# != 1 ]; then > >> + echo expected one argument: '<'dtrace-path'>' > >> + exit 2 > >> +fi > >> + > >> +dtrace=$1 > >> +CC=/usr/bin/gcc > >> +CFLAGS="-I${PWD}/test/unittest/usdt" > >> + > >> +DIRNAME="$tmpdir/usdt-notes.$$.$RANDOM" > >> +mkdir -p $DIRNAME > >> +cd $DIRNAME > >> + > >> +cat > test.c <<EOF > >> +#define _SDT_HAS_SEMAPHORES 1 > >> +#include <sdt_notes.h> > >> + > >> +#define SEC(name) __attribute__((section(name), used)) > >> + > >> +unsigned short test_prov_zero_semaphore SEC(".probes"); > >> +unsigned short test_prov_one_semaphore SEC(".probes"); > >> +unsigned short test_prov_two_semaphore SEC(".probes"); > >> +unsigned short test_prov_three_semaphore SEC(".probes"); > >> +unsigned short test_prov_four_semaphore SEC(".probes"); > >> +unsigned short test_prov_five_semaphore SEC(".probes"); > >> +unsigned short test_prov_six_semaphore SEC(".probes"); > >> +unsigned short test_prov_seven_semaphore SEC(".probes"); > >> +unsigned short test_prov_eight_semaphore SEC(".probes"); > >> +unsigned short test_prov_nine_semaphore SEC(".probes"); > >> +unsigned short test_prov_ten_semaphore SEC(".probes"); > >> +unsigned short test_prov_eleven_semaphore SEC(".probes"); > >> +unsigned short test_prov_twelve_semaphore SEC(".probes"); > >> + > >> +int > >> +main(int argc, char **argv) > >> +{ > >> + if (test_prov_zero_semaphore) > >> + STAP_PROBE(test_prov, zero); > >> + if (test_prov_one_semaphore) > >> + STAP_PROBE1(test_prov, one, argc); > >> + if (test_prov_two_semaphore) > >> + STAP_PROBE2(test_prov, two, 2, 3); > >> + if (test_prov_three_semaphore) > >> + STAP_PROBE3(test_prov, three, 4, 5, 7); > >> + if (test_prov_four_semaphore) > >> + STAP_PROBE4(test_prov, four, 7, 8, 9, 10); > >> + if (test_prov_five_semaphore) > >> + STAP_PROBE5(test_prov, five, 11, 12, 13, 14, 15); > >> + if (test_prov_six_semaphore) > >> + STAP_PROBE6(test_prov, six, 16, 17, 18, 19, 20, 21); > >> + if (test_prov_seven_semaphore) > >> + STAP_PROBE7(test_prov, seven, 22, 23, 24, 25, 26, 27, 28); > >> + if (test_prov_eight_semaphore) > >> + STAP_PROBE8(test_prov, eight, 29, 30, 31, 32, 33, 34, 35, 36); > >> + if (test_prov_nine_semaphore) > >> + STAP_PROBE9(test_prov, nine, 37, 38, 39, 40, 41, 42, 43, 44, 45); > >> + if (test_prov_ten_semaphore) > >> + STAP_PROBE10(test_prov, ten, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55); > >> + if (test_prov_eleven_semaphore) > >> + STAP_PROBE11(test_prov, eleven, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66); > >> + if (test_prov_twelve_semaphore) > >> + STAP_PROBE12(test_prov, twelve, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78); > >> +} > >> +EOF > >> + > >> +${CC} ${CFLAGS} -o test test.c > >> +if [ $? -ne 0 ]; then > >> + echo "failed to compile test.c" >& 2 > >> + exit 1 > >> +fi > >> + > >> +$dtrace -c ./test -qs /dev/stdin <<EOF > >> +test_prov\$target:::zero > >> +{ > >> + printf("%s:%s:%s\n", probemod, probefunc, probename); > >> +} > >> + > >> +test_prov\$target:::one > >> +{ > >> + printf("%s:%s:%s:%li\n", probemod, probefunc, probename, arg0); > >> +} > >> + > >> +test_prov\$target:::two > >> +{ > >> + printf("%s:%s:%s:%li:%li\n", probemod, probefunc, probename, arg0, arg1); > >> +} > >> + > >> +test_prov\$target:::three > >> +{ > >> + printf("%s:%s:%s:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, > >> + arg2); > >> +} > >> + > >> +test_prov\$target:::four > >> +{ > >> + printf("%s:%s:%s:%li:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, > >> + arg2, arg3); > >> +} > >> + > >> +test_prov\$target:::five > >> +{ > >> + printf("%s:%s:%s:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > >> + arg0, arg1, arg2, arg3, arg4); > >> +} > >> + > >> +test_prov\$target:::six > >> +{ > >> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > >> + arg0, arg1, arg2, arg3, arg4, arg5); > >> +} > >> + > >> +test_prov\$target:::seven > >> +{ > >> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > >> + arg0, arg1, arg2, arg3, arg4, arg5, arg6); > >> +} > >> + > >> +test_prov\$target:::eight > >> +{ > >> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > >> + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); > >> +} > >> + > >> +test_prov\$target:::nine > >> +{ > >> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > >> + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); > >> +} > >> + > >> +test_prov\$target:::ten, > >> +test_prov\$target:::eleven, > >> +test_prov\$target:::twelve > >> +{ > >> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, > >> + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); > >> +} > >> +EOF > >> +status=$? > >> + > >> +exit $status > >> -- > >> 2.39.3 > >> ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [PATCH v6 7/7] selftests/usdt: add is-enabled stapsdt tests using semaphores 2025-07-29 11:49 ` Kris Van Hees @ 2025-07-29 13:16 ` Alan Maguire 0 siblings, 0 replies; 12+ messages in thread From: Alan Maguire @ 2025-07-29 13:16 UTC (permalink / raw) To: Kris Van Hees; +Cc: dtrace, dtrace-devel On 29/07/2025 12:49, Kris Van Hees wrote: > On Tue, Jul 29, 2025 at 08:37:16AM +0100, Alan Maguire wrote: >> On 29/07/2025 03:07, Kris Van Hees wrote: >>> This test is flawed because you never initialize the semaphores. If you change >>> the code to assign 0 to then, then the test fails because the probes never >>> fire. That makes sense because your implementation does not actually do >> >> Hmm, I don't see this behaviour. If I change the semaphores to be set to >> 0, i.e. >> >> -unsigned short test_prov_zero_semaphore SEC(".probes"); >> -unsigned short test_prov_one_semaphore SEC(".probes"); >> -unsigned short test_prov_two_semaphore SEC(".probes"); >> -unsigned short test_prov_three_semaphore SEC(".probes"); >> -unsigned short test_prov_four_semaphore SEC(".probes"); >> -unsigned short test_prov_five_semaphore SEC(".probes"); >> -unsigned short test_prov_six_semaphore SEC(".probes"); >> -unsigned short test_prov_seven_semaphore SEC(".probes"); >> -unsigned short test_prov_eight_semaphore SEC(".probes"); >> -unsigned short test_prov_nine_semaphore SEC(".probes"); >> -unsigned short test_prov_ten_semaphore SEC(".probes"); >> -unsigned short test_prov_eleven_semaphore SEC(".probes"); >> -unsigned short test_prov_twelve_semaphore SEC(".probes"); >> +unsigned short test_prov_zero_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_one_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_two_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_three_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_four_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_five_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_six_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_seven_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_eight_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_nine_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_ten_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_eleven_semaphore SEC(".probes") = 0; >> +unsigned short test_prov_twelve_semaphore SEC(".probes") = 0; >> >> ...the test still passes. Are you perhaps initializing the semaphores in >> main()? This has the potential to overwrite the kernel-updated values >> which are incremented when the probes are enabled. > > I put the assignment before the SEC(...) which may have caused the semaphore > to perhaps not be created as expected. > > Also, do you actually need the SEC(...) for this? From the look of the code > in the kernel, any offset in the inode would work, and unnless I overlooked it > I also do not see anything in the macros for systemtap that require a specific > section for the semaphore variables. > yep I think we can remove that requirement alright; I validated tests still pass. >>> anything with the semaphore, i.e. if the probe it relatees to is enabled, >>> nothing happens to the semaphore, so while you do store the address of the >>> semaphore in patch 2, it is never used for anything, so this test passing is >> >> The refcntr address is set in parentheses where the probe is set up - >> see uprobe_create(): >> >> if (refcntr_off) { >> if (asprintf(&spec, "%s:0x%lx(0x%lx)", mapping_fn, addr, >> refcntr_off) < 0) >> return NULL; >> } else { >> if (asprintf(&spec, "%s:0x%lx", mapping_fn, addr) < 0) >> return NULL; >> } >> >> The parenthesized value is then handed off to the kernel to >> reference-count probe enablings. > > Ah, overlooked that :) My bad. Sorry about the false alarm on that. > > However, there definitely should be tests that also check that when the probe > is *not* enabled, the code is indeed also not executed. > Good idea. How about the following; removes the SEC() specification, initializes semaphores to 0 and prints a message in the is-enabled clause of a disabled probe which we expect _not_ to see since the probe is disabled. With these changes the test passes: diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.r b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r index db6d18cb..80271b89 100644 --- a/test/unittest/usdt/tst.stapsdt-notes-isenabled.r +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r @@ -8,7 +8,6 @@ test:main:six:16:17:18:19:20:21 test:main:seven:22:23:24:25:26:27:28 test:main:eight:29:30:31:32:33:34:35:36 test:main:nine:37:38:39:40:41:42:43:44:45 -test:main:ten:46:47:48:49:50:51:52:53:54:55 test:main:eleven:56:57:58:59:60:61:62:63:64:65 test:main:twelve:67:68:69:70:71:72:73:74:75:76 diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh index 99fcc844..c73ef7fa 100755 --- a/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh @@ -23,24 +23,23 @@ mkdir -p $DIRNAME cd $DIRNAME cat > test.c <<EOF +#include <stdio.h> #define _SDT_HAS_SEMAPHORES 1 #include <sdt_notes.h> -#define SEC(name) __attribute__((section(name), used)) - -unsigned short test_prov_zero_semaphore SEC(".probes"); -unsigned short test_prov_one_semaphore SEC(".probes"); -unsigned short test_prov_two_semaphore SEC(".probes"); -unsigned short test_prov_three_semaphore SEC(".probes"); -unsigned short test_prov_four_semaphore SEC(".probes"); -unsigned short test_prov_five_semaphore SEC(".probes"); -unsigned short test_prov_six_semaphore SEC(".probes"); -unsigned short test_prov_seven_semaphore SEC(".probes"); -unsigned short test_prov_eight_semaphore SEC(".probes"); -unsigned short test_prov_nine_semaphore SEC(".probes"); -unsigned short test_prov_ten_semaphore SEC(".probes"); -unsigned short test_prov_eleven_semaphore SEC(".probes"); -unsigned short test_prov_twelve_semaphore SEC(".probes"); +unsigned short test_prov_zero_semaphore = 0; +unsigned short test_prov_one_semaphore = 0; +unsigned short test_prov_two_semaphore = 0; +unsigned short test_prov_three_semaphore = 0; +unsigned short test_prov_four_semaphore = 0; +unsigned short test_prov_five_semaphore = 0; +unsigned short test_prov_six_semaphore = 0; +unsigned short test_prov_seven_semaphore = 0; +unsigned short test_prov_eight_semaphore = 0; +unsigned short test_prov_nine_semaphore = 0; +unsigned short test_prov_ten_semaphore = 0; +unsigned short test_prov_eleven_semaphore = 0; +unsigned short test_prov_twelve_semaphore = 0; int main(int argc, char **argv) @@ -65,8 +64,11 @@ main(int argc, char **argv) STAP_PROBE8(test_prov, eight, 29, 30, 31, 32, 33, 34, 35, 36); if (test_prov_nine_semaphore) STAP_PROBE9(test_prov, nine, 37, 38, 39, 40, 41, 42, 43, 44, 45); - if (test_prov_ten_semaphore) + if (test_prov_ten_semaphore) { + printf("should not see this since ten probe is not enabled!\n"); STAP_PROBE10(test_prov, ten, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55); + fflush(stdout); + } if (test_prov_eleven_semaphore) STAP_PROBE11(test_prov, eleven, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66); if (test_prov_twelve_semaphore) @@ -138,7 +140,6 @@ test_prov\$target:::nine arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); } -test_prov\$target:::ten, test_prov\$target:::eleven, test_prov\$target:::twelve { >> >>> actually accidental because the semaphore initial value is (apparently) most >>> commonly *not* 0. >>> >>> On Mon, Jul 28, 2025 at 05:36:11PM +0100, Alan Maguire wrote: >>>> Is-eanbled probes are implemented using semaphores where the >>>> semaphore address is specified in the ELF notes and passed >>>> in at probe creation time to have the kernel reference-count >>>> probes; this allows us to have argument assembly code that >>>> only gets executed when the stapsdt probe is in use. >>>> >>>> Signed-off-by: Alan Maguire <alan.maguire@oracle.com> >>>> --- >>>> .../usdt/tst.stapsdt-notes-isenabled.r | 14 ++ >>>> .../usdt/tst.stapsdt-notes-isenabled.sh | 151 ++++++++++++++++++ >>>> 2 files changed, 165 insertions(+) >>>> create mode 100644 test/unittest/usdt/tst.stapsdt-notes-isenabled.r >>>> create mode 100755 test/unittest/usdt/tst.stapsdt-notes-isenabled.sh >>>> >>>> diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.r b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r >>>> new file mode 100644 >>>> index 00000000..db6d18cb >>>> --- /dev/null >>>> +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.r >>>> @@ -0,0 +1,14 @@ >>>> +test:main:zero >>>> +test:main:one:1 >>>> +test:main:two:2:3 >>>> +test:main:three:4:5:7 >>>> +test:main:four:7:8:9:10 >>>> +test:main:five:11:12:13:14:15 >>>> +test:main:six:16:17:18:19:20:21 >>>> +test:main:seven:22:23:24:25:26:27:28 >>>> +test:main:eight:29:30:31:32:33:34:35:36 >>>> +test:main:nine:37:38:39:40:41:42:43:44:45 >>>> +test:main:ten:46:47:48:49:50:51:52:53:54:55 >>>> +test:main:eleven:56:57:58:59:60:61:62:63:64:65 >>>> +test:main:twelve:67:68:69:70:71:72:73:74:75:76 >>>> + >>>> diff --git a/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh >>>> new file mode 100755 >>>> index 00000000..99fcc844 >>>> --- /dev/null >>>> +++ b/test/unittest/usdt/tst.stapsdt-notes-isenabled.sh >>>> @@ -0,0 +1,151 @@ >>>> +#!/bin/bash >>>> +# >>>> +# Oracle Linux DTrace. >>>> +# Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. >>>> +# Licensed under the Universal Permissive License v 1.0 as shown at >>>> +# http://oss.oracle.com/licenses/upl. >>>> + >>>> +# This test covers all stapsdt probes fired by the STAP_PROBEn macros. >>>> +# Arguments values are checked only for first 10 arguments because >>>> +# there is support for arg0 ... arg9 only at this moment. >>>> + >>>> +if [ $# != 1 ]; then >>>> + echo expected one argument: '<'dtrace-path'>' >>>> + exit 2 >>>> +fi >>>> + >>>> +dtrace=$1 >>>> +CC=/usr/bin/gcc >>>> +CFLAGS="-I${PWD}/test/unittest/usdt" >>>> + >>>> +DIRNAME="$tmpdir/usdt-notes.$$.$RANDOM" >>>> +mkdir -p $DIRNAME >>>> +cd $DIRNAME >>>> + >>>> +cat > test.c <<EOF >>>> +#define _SDT_HAS_SEMAPHORES 1 >>>> +#include <sdt_notes.h> >>>> + >>>> +#define SEC(name) __attribute__((section(name), used)) >>>> + >>>> +unsigned short test_prov_zero_semaphore SEC(".probes"); >>>> +unsigned short test_prov_one_semaphore SEC(".probes"); >>>> +unsigned short test_prov_two_semaphore SEC(".probes"); >>>> +unsigned short test_prov_three_semaphore SEC(".probes"); >>>> +unsigned short test_prov_four_semaphore SEC(".probes"); >>>> +unsigned short test_prov_five_semaphore SEC(".probes"); >>>> +unsigned short test_prov_six_semaphore SEC(".probes"); >>>> +unsigned short test_prov_seven_semaphore SEC(".probes"); >>>> +unsigned short test_prov_eight_semaphore SEC(".probes"); >>>> +unsigned short test_prov_nine_semaphore SEC(".probes"); >>>> +unsigned short test_prov_ten_semaphore SEC(".probes"); >>>> +unsigned short test_prov_eleven_semaphore SEC(".probes"); >>>> +unsigned short test_prov_twelve_semaphore SEC(".probes"); >>>> + >>>> +int >>>> +main(int argc, char **argv) >>>> +{ >>>> + if (test_prov_zero_semaphore) >>>> + STAP_PROBE(test_prov, zero); >>>> + if (test_prov_one_semaphore) >>>> + STAP_PROBE1(test_prov, one, argc); >>>> + if (test_prov_two_semaphore) >>>> + STAP_PROBE2(test_prov, two, 2, 3); >>>> + if (test_prov_three_semaphore) >>>> + STAP_PROBE3(test_prov, three, 4, 5, 7); >>>> + if (test_prov_four_semaphore) >>>> + STAP_PROBE4(test_prov, four, 7, 8, 9, 10); >>>> + if (test_prov_five_semaphore) >>>> + STAP_PROBE5(test_prov, five, 11, 12, 13, 14, 15); >>>> + if (test_prov_six_semaphore) >>>> + STAP_PROBE6(test_prov, six, 16, 17, 18, 19, 20, 21); >>>> + if (test_prov_seven_semaphore) >>>> + STAP_PROBE7(test_prov, seven, 22, 23, 24, 25, 26, 27, 28); >>>> + if (test_prov_eight_semaphore) >>>> + STAP_PROBE8(test_prov, eight, 29, 30, 31, 32, 33, 34, 35, 36); >>>> + if (test_prov_nine_semaphore) >>>> + STAP_PROBE9(test_prov, nine, 37, 38, 39, 40, 41, 42, 43, 44, 45); >>>> + if (test_prov_ten_semaphore) >>>> + STAP_PROBE10(test_prov, ten, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55); >>>> + if (test_prov_eleven_semaphore) >>>> + STAP_PROBE11(test_prov, eleven, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66); >>>> + if (test_prov_twelve_semaphore) >>>> + STAP_PROBE12(test_prov, twelve, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78); >>>> +} >>>> +EOF >>>> + >>>> +${CC} ${CFLAGS} -o test test.c >>>> +if [ $? -ne 0 ]; then >>>> + echo "failed to compile test.c" >& 2 >>>> + exit 1 >>>> +fi >>>> + >>>> +$dtrace -c ./test -qs /dev/stdin <<EOF >>>> +test_prov\$target:::zero >>>> +{ >>>> + printf("%s:%s:%s\n", probemod, probefunc, probename); >>>> +} >>>> + >>>> +test_prov\$target:::one >>>> +{ >>>> + printf("%s:%s:%s:%li\n", probemod, probefunc, probename, arg0); >>>> +} >>>> + >>>> +test_prov\$target:::two >>>> +{ >>>> + printf("%s:%s:%s:%li:%li\n", probemod, probefunc, probename, arg0, arg1); >>>> +} >>>> + >>>> +test_prov\$target:::three >>>> +{ >>>> + printf("%s:%s:%s:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, >>>> + arg2); >>>> +} >>>> + >>>> +test_prov\$target:::four >>>> +{ >>>> + printf("%s:%s:%s:%li:%li:%li:%li\n", probemod, probefunc, probename, arg0, arg1, >>>> + arg2, arg3); >>>> +} >>>> + >>>> +test_prov\$target:::five >>>> +{ >>>> + printf("%s:%s:%s:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >>>> + arg0, arg1, arg2, arg3, arg4); >>>> +} >>>> + >>>> +test_prov\$target:::six >>>> +{ >>>> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >>>> + arg0, arg1, arg2, arg3, arg4, arg5); >>>> +} >>>> + >>>> +test_prov\$target:::seven >>>> +{ >>>> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >>>> + arg0, arg1, arg2, arg3, arg4, arg5, arg6); >>>> +} >>>> + >>>> +test_prov\$target:::eight >>>> +{ >>>> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >>>> + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); >>>> +} >>>> + >>>> +test_prov\$target:::nine >>>> +{ >>>> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >>>> + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); >>>> +} >>>> + >>>> +test_prov\$target:::ten, >>>> +test_prov\$target:::eleven, >>>> +test_prov\$target:::twelve >>>> +{ >>>> + printf("%s:%s:%s:%li:%li:%li:%li:%li:%li:%li:%li:%li:%li\n", probemod, probefunc, probename, >>>> + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); >>>> +} >>>> +EOF >>>> +status=$? >>>> + >>>> +exit $status >>>> -- >>>> 2.39.3 >>>> ^ permalink raw reply related [flat|nested] 12+ messages in thread
end of thread, other threads:[~2025-07-29 13:16 UTC | newest] Thread overview: 12+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2025-07-28 16:36 [PATCH v6 0/7] add support for stapsdt probes Alan Maguire 2025-07-28 16:36 ` [PATCH v6 1/7] usdt: have copy_args() count args while parsing them Alan Maguire 2025-07-28 16:36 ` [PATCH v6 2/7] support stapsdt ELF-note-defined static probes Alan Maguire 2025-07-28 16:36 ` [PATCH v6 3/7] selftests/usdt: add test for stapsdt note-defined probe firing, args Alan Maguire 2025-07-28 16:36 ` [PATCH v6 4/7] selftests/usdt: add test for stapsdt notes in shared library Alan Maguire 2025-07-28 16:36 ` [PATCH v6 5/7] selftests/usdt: add test covering different forms of stapsdt note args Alan Maguire 2025-07-28 16:36 ` [PATCH v6 6/7] selftests/usdt: add test for stapsdt note-defined probe firing in -fPIE binary Alan Maguire 2025-07-28 16:36 ` [PATCH v6 7/7] selftests/usdt: add is-enabled stapsdt tests using semaphores Alan Maguire 2025-07-29 2:07 ` Kris Van Hees 2025-07-29 7:37 ` Alan Maguire 2025-07-29 11:49 ` Kris Van Hees 2025-07-29 13:16 ` Alan Maguire
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.