[dtrace-discuss] USDT probe problems?

[James McIlree]

	I've run into some potential oddness when trying to use
USDT probes. I've boiled it down into a small test case, which I've
included below.

	Here is some sample output:

/home/ovrskeek> ./usdt
floatArg: 1.000000 doubleArg: 1.500000 longLongArg: feeaadd00000001
floatArg: 2.000000 doubleArg: 2.500000 longLongArg: feeaadd00000002
floatArg: 3.000000 doubleArg: 3.500000 longLongArg: feeaadd00000003
floatArg: 4.000000 doubleArg: 4.500000 longLongArg: feeaadd00000004

/home/ovrskeek# dtrace -n 'fooProvider*:::longLongProbe  
{ trace(args[0]); }'
dtrace: description 'fooProvider*:::longLongProbe ' matched 1 probe
CPU     ID                    FUNCTION:NAME
   1  52718               main:longLongProbe                 2
   1  52718               main:longLongProbe                 3
   1  52718               main:longLongProbe                 4

/home/ovrskeek# dtrace -n 'fooProvider*:::floatProbe  
{ trace(args[0]); }'
dtrace: invalid probe specifier fooProvider*:::floatProbe  
{ trace(args[0]); }: in action list: translator for args[0] from float  
to float is not defined

/home/ovrskeek# dtrace -n 'fooProvider*:::doubleProbe  
{ trace(args[0]); }'
dtrace: invalid probe specifier fooProvider*:::doubleProbe  
{ trace(args[0]); }: in action list: translator for args[0] from  
double to double is not defined

	From poking around in the source code, it appears the
first problem is related to how USDT arguments are read from the stack.

	I wasn't certain if the second two were an oversight,
or an intentional guard against using floats/doubles (which may
take ABI groveling to find).

	Doctor, doctor, it hurts when I use long long's in my
USDT probes :-). Any advice?

	James McIlree


----------- fooProvider.d -------------------

provider fooProvider {
         probe floatProbe(float);
         probe doubleProbe(double);
         probe longLongProbe(long long);
};

------------ usdt.c ------------------------

#include <stdio.h>
#include "fooProvider.h"

int main() {
         float floatArg = 1.0f;
         double doubleArg = 1.5;
         long long longLongArg = 0x0FEEAADD00000001LL;

         while (1) {
                 FOOPROVIDER_FLOATPROBE(floatArg);
                 FOOPROVIDER_DOUBLEPROBE(doubleArg);
                 FOOPROVIDER_LONGLONGPROBE(longLongArg);

                 printf("floatArg: %f doubleArg: %f longLongArg: %llx 
\n", (double)floatArg, doubleArg, (unsigned long long)longLongArg);
                 floatArg++;
                 doubleArg++;
                 longLongArg++;

                 sleep(1);
         }

         return 0;
}