Class: StapSDT::Provider

Inherits:
Object
  • Object
show all
Defined in:
lib/stapsdt/provider.rb,
ext/stapsdt/stapsdt.c

Overview

Collection of probes that can be activated and deactivated

Providers are the entry point for probe definition

After creation, probes are added with #add_probe and then activated with #load. Probes can only be defined before the provider gets loaded.

Defined Under Namespace

Classes: StateError

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Provider

Returns a new instance of Provider.



12
13
14
 
# File 'lib/stapsdt/provider.rb', line 12

def initialize
    @loaded = false
end

Class Method Details

.new(_name) ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
 
# File 'ext/stapsdt/stapsdt.c', line 24

VALUE provider_new(VALUE self, VALUE _name)
{
    char const* name = StringValueCStr(_name);
    SDTProvider_t* provider = providerInit(name);
    if (!provider)
        rb_raise(rb_eRuntimeError, "could not create provider with name %s", name);

    Provider_t* wrap = ALLOC(Provider_t);
    wrap->provider = provider;
    return rb_data_object_wrap(rb_mProvider, wrap, NULL, (RUBY_DATA_FUNC)provider_free);
}

Instance Method Details

#add_probe(probe_name, *arg_types) ⇒ Probe

Add a new probe to this provider

Probes must be added before the provider is loaded. Call #unload to add new probes to an already-loaded provider

Parameters:

  • probe_name (String) —

    the name of the probe

  • arg_types (Array) —

    the type of probe arguments. It is either one of the ARG_ constants defined within StapSDT, or one of the Integer, Float and String classes.

Returns:

Raises:

  • (StateError) —

    if the provider was already loaded



55
56
57
58
59
60
 
# File 'lib/stapsdt/provider.rb', line 55

def add_probe(probe_name, *arg_types)
    if loaded?
        raise StateError, "already loaded, call #unload before adding new probes"
    end
    add_probe_c(probe_name, *arg_types)
end

#add_probe_c(*args) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'ext/stapsdt/stapsdt.c', line 65

VALUE provider_add_probe(int argc, VALUE* argv, VALUE self)
{
    VALUE input_args[MAX_ARGUMENTS];
    int args[MAX_ARGUMENTS];
    if (argc < 1)
        rb_raise(rb_eArgError, "expected at least 1 argument, got 0");
    if (argc > MAX_ARGUMENTS + 1)
        rb_raise(rb_eArgError,
            "libstapstd only supports up to %i arguments, got %i",
                MAX_ARGUMENTS, argc - 1);

    for (int i = 0; i < argc - 1; ++i)
    {
        VALUE arg_type = argv[i + 1];
        input_args[i] = arg_type;
        if (arg_type == rb_cString || arg_type == rb_cFloat || arg_type == rb_cInteger)
            args[i] = uint64;
        else
            args[i] = NUM2INT(arg_type);
    }

    char const* probe_name = StringValueCStr(argv[0]);

    Provider_t* wrap;
    Data_Get_Struct(self, Provider_t, wrap);

    SDTProbe_t* probe = NULL;
    if (argc == 1)
        probe = providerAddProbe(wrap->provider, probe_name, 0);
    else if (argc == 2)
        probe = providerAddProbe(wrap->provider, probe_name, 1,
            (ArgType_t)args[0]);
    else if (argc == 3)
        probe = providerAddProbe(wrap->provider, probe_name, 2,
            (ArgType_t)args[0], (ArgType_t)args[1]);
    else if (argc == 4)
        probe = providerAddProbe(wrap->provider, probe_name, 3,
            (ArgType_t)args[0], (ArgType_t)args[1], (ArgType_t)args[2]);
    else if (argc == 5)
        probe = providerAddProbe(wrap->provider, probe_name, 4,
            (ArgType_t)args[0], (ArgType_t)args[1], (ArgType_t)args[2],
            (ArgType_t)args[3]);
    else if (argc == 6)
        probe = providerAddProbe(wrap->provider, probe_name, 5,
            (ArgType_t)args[0], (ArgType_t)args[1], (ArgType_t)args[2],
            (ArgType_t)args[3], (ArgType_t)args[4]);
    else if (argc == 7)
        probe = providerAddProbe(wrap->provider, probe_name, 6,
            (ArgType_t)args[0], (ArgType_t)args[1], (ArgType_t)args[2],
            (ArgType_t)args[3], (ArgType_t)args[4], (ArgType_t)args[5]);

    if (!probe)
        rb_raise(rb_eArgError, "failed to create probe");

    Probe_t* probe_wrap = ALLOC(Probe_t);
    memcpy(probe_wrap->input_args, input_args, sizeof(VALUE)*(argc - 1));
    probe_wrap->probe = probe;
    /* NOTE: probes cannot be deallocated. They're freed when the provider is */
    return rb_data_object_wrap(rb_mProbe, probe_wrap, NULL, NULL);
}

#load ⇒ Object

Load the provider

Raises:

  • (StateError) —

    if the provider was already loaded. Call #unload first in this case



27
28
29
30
31
32
 
# File 'lib/stapsdt/provider.rb', line 27

def load
    raise StateError, "already loaded, call #unload first" if loaded?

    load_c
    @loaded = true
end

#load_c ⇒ Object 



47
48
49
50
51
52
53
54
 
# File 'ext/stapsdt/stapsdt.c', line 47

VALUE provider_load(VALUE self)
{
    Provider_t* wrap;
    Data_Get_Struct(self, Provider_t, wrap);
    int result = providerLoad(wrap->provider);
    interpretError(result, wrap);
    return Qnil;
}

#loaded? ⇒ Boolean

Whether this provider has been loaded

Returns:

  • (Boolean) 


17
18
19
 
# File 'lib/stapsdt/provider.rb', line 17

def loaded?
    @loaded
end

#unload ⇒ Object

Unloads the provider

Does nothing if the provider was not yet loaded



37
38
39
40
41
42
 
# File 'lib/stapsdt/provider.rb', line 37

def unload
    return unless loaded?

    unload_c
    @loaded = false
end

#unload_c ⇒ Object 



56
57
58
59
60
61
62
63
 
# File 'ext/stapsdt/stapsdt.c', line 56

VALUE provider_unload(VALUE self)
{
    Provider_t* wrap;
    Data_Get_Struct(self, Provider_t, wrap);
    int result = providerUnload(wrap->provider);
    interpretError(result, wrap);
    return Qnil;
}