1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
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
|
// stapdyn mutator functions
// Copyright (C) 2012-2013 Red Hat Inc.
//
// This file is part of systemtap, and is free software. You can
// redistribute it and/or modify it under the terms of the GNU General
// Public License (GPL); either version 2, or (at your option) any
// later version.
#ifndef MUTATOR_H
#define MUTATOR_H
#include <memory>
#include <string>
#include <vector>
#include <dyninst/BPatch.h>
#include <dyninst/BPatch_module.h>
#include <dyninst/BPatch_process.h>
#include <dyninst/BPatch_thread.h>
#include "dynprobe.h"
#include "dynutil.h"
#include "mutatee.h"
extern "C" {
#include "../runtime/dyninst/stapdyn.h"
}
// The mutator drives all instrumentation.
class mutator {
private:
BPatch patch;
void* module; // the locally dlopened probe module
std::string module_name; // the filename of the probe module
std::vector<std::string> modoptions; // custom globals from -G option
std::string module_shmem; // the global name of this module's shared memory
std::vector<dynprobe_target> targets; // the probe targets in the module
std::vector<std::shared_ptr<mutatee> > mutatees; // all attached target processes
std::shared_ptr<mutatee> target_mutatee; // the main target process we created or attached
bool p_target_created; // we only kill and wait on the target we created
bool p_target_error; // indicates whether the target exited non-zero;
sigset_t signals_received; // record all signals we've caught
// disable implicit constructors by not implementing these
mutator (const mutator& other);
mutator& operator= (const mutator& other);
// Initialize the module global variables
bool init_modoptions();
// Initialize the session attributes
void init_session_attributes();
// Initialize the module session
bool run_module_init();
// Shutdown the module session
bool run_module_exit();
// Check the status of all mutatees
bool update_mutatees();
// Do probes matching 'flag' exist?
bool matching_probes_exist(uint64_t flag);
// Find a mutatee which matches the given process, else return NULL
std::shared_ptr<mutatee> find_mutatee(BPatch_process* process);
// Stashed utrace probe enter function pointer.
decltype(&enter_dyninst_utrace_probe) utrace_enter_fn;
public:
mutator (const std::string& module_name,
std::vector<std::string>& module_options);
~mutator ();
// Load the stap module and initialize all probe info.
bool load ();
// Create a new process with the given command line.
bool create_process(const std::string& command);
// Attach to a specific existing process.
bool attach_process(BPatch_process* process);
bool attach_process(pid_t pid);
// Start the actual systemtap session!
bool run ();
// Get the final exit status of this mutator
int exit_status();
// Callback to respond to dynamically loaded libraries.
// Check if it matches our targets, and instrument accordingly.
void dynamic_library_callback(BPatch_thread *thread,
BPatch_object *object,
bool load);
// Callback to respond to post fork events. Check if it matches
// our targets, and handle accordingly.
void post_fork_callback(BPatch_thread *parent, BPatch_thread *child);
void exec_callback(BPatch_thread *thread);
void exit_callback(BPatch_thread *thread, BPatch_exitType type);
void thread_create_callback(BPatch_process *proc, BPatch_thread *thread);
void thread_destroy_callback(BPatch_process *proc, BPatch_thread *thread);
// Callback to respond to signals.
void signal_callback(int signal);
};
#endif // MUTATOR_H
/* vim: set sw=2 ts=8 cino=>4,n-2,{2,^-2,t0,(0,u0,w1,M1 : */
|
