1 // Copyright (C) Andrew Tridgell 2002 (original file)
2 // Copyright (C) 2006-2011 Red Hat Inc. (systemtap changes)
4 // This program is free software; you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation; either version 2 of the License, or
7 // (at your option) any later version.
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU General Public License for more details.
14 // You should have received a copy of the GNU General Public License
15 // along with this program. If not, see <http://www.gnu.org/licenses/>.
30 #include <sys/types.h>
43 std::ostringstream parm_stream
;
46 stap_hash() { start(); }
47 stap_hash(const stap_hash
&base
) { md4
= base
.md4
; parm_stream
<< base
.parm_stream
.str(); }
51 void add(const std::string
& description
, const unsigned char *buffer
, size_t size
);
52 template<typename T
> void add(const std::string
& d
, const T
& x
);
53 void add(const std::string
& d
, const char *s
) { add((const std::string
&)d
, (const unsigned char *)s
, strlen(s
)); }
54 void add(const std:: string
& d
, const std::string
& s
) { add(d
, (const unsigned char *)s
.c_str(), s
.length()); }
56 void add_path(const std::string
& description
, const std::string
& path
);
58 void result(std::string
& r
);
59 std::string
get_parms() { return parm_stream
.str(); }
71 stap_hash::add(const std::string
& description
, const unsigned char *buffer
, size_t size
)
73 parm_stream
<< description
<< buffer
<< endl
;
74 mdfour_update(&md4
, buffer
, size
);
78 template <typename T
> void
79 stap_hash::add(const std::string
& d
, const T
& x
)
81 parm_stream
<< d
<< x
<< endl
;
82 mdfour_update(&md4
, (const unsigned char *)&x
, sizeof(x
));
87 stap_hash::add_path(const std::string
& description
, const std::string
& path
)
90 memset (&st
, 0, sizeof(st
));
92 if (stat(path
.c_str(), &st
) != 0)
93 st
.st_size
= st
.st_mtime
= -1;
95 add(description
+ "Path: ", path
);
96 add(description
+ "Size: ", st
.st_size
);
97 add(description
+ "Timestamp: ", st
.st_mtime
);
102 stap_hash::result(string
& r
)
104 ostringstream rstream
;
105 unsigned char sum
[16];
107 mdfour_update(&md4
, NULL
, 0);
108 mdfour_result(&md4
, sum
);
110 for (int i
=0; i
<16; i
++)
112 rstream
<< hex
<< setfill('0') << setw(2) << (unsigned)sum
[i
];
114 rstream
<< "_" << setw(0) << dec
<< (unsigned)md4
.totalN
;
118 void create_hash_log(const string
&type_str
, const string
&parms
, const string
&result
, const string
&hash_log_path
)
123 string
time_str(ctime (&rawtime
));
125 log_file
.open(hash_log_path
.c_str());
126 log_file
<< "[" << time_str
.substr(0,time_str
.length()-1); // erase terminated '\n'
127 log_file
<< "] " << type_str
<< ":" << endl
;
128 log_file
<< parms
<< endl
;
129 log_file
<< _("result:") << result
<< endl
;
133 static const stap_hash
&
134 get_base_hash (systemtap_session
& s
)
139 s
.base_hash
= new stap_hash();
140 stap_hash
& h
= *s
.base_hash
;
142 // Hash kernel release and arch.
143 h
.add("Kernel Release: ", s
.kernel_release
);
144 h
.add_path("Kernel Build Tree ", s
.kernel_build_tree
);
145 h
.add("Architecture: ", s
.architecture
);
147 // Hash a few kernel version/build-id files too
148 // (useful for kernel developers reusing a single source tree)
149 h
.add_path("Kernel Build Tree .config ", s
.kernel_build_tree
+ "/.config");
150 h
.add_path("Kernel Build Tree .version ", s
.kernel_build_tree
+ "/.version");
151 h
.add_path("Kernel Build Tree compile.h ", s
.kernel_build_tree
+ "/include/linux/compile.h");
152 h
.add_path("Kernel Build Tree version.h ", s
.kernel_build_tree
+ "/include/linux/version.h");
153 h
.add_path("Kernel Build Tree utsrelease.h ", s
.kernel_build_tree
+ "/include/linux/utsrelease.h");
155 // Hash runtime path (that gets added in as "-R path").
156 h
.add_path("Runtime ", s
.runtime_path
);
157 h
.add_path("Runtime transport ", s
.runtime_path
+ "/transport");
158 h
.add_path("Runtime unwind ", s
.runtime_path
+ "/unwind");
159 h
.add_path("Runtime sub ", s
.runtime_path
+
160 (s
.runtime_usermode_p() ? "/dyninst" : "/linux"));
162 // Hash compiler path, size, and mtime. We're just going to assume
163 // we'll be using gcc. XXX: getting kbuild to spit out out would be
164 // better, especially since this is fooled by ccache.
165 h
.add_path("Compiler ", find_executable("gcc"));
167 // Hash the systemtap size and mtime. We could use VERSION/DATE,
168 // but when developing systemtap that doesn't work well (since you
169 // can compile systemtap multiple times in 1 day). Since we don't
170 // know exactly where we're getting run from, we'll use
171 // /proc/self/exe (and we resolve it ourselves to help valgrind).
172 h
.add_path("Systemtap ", get_self_path());
179 create_hashdir (systemtap_session
& s
, const string
& result
, string
& hashdir
)
183 // Use a N level subdir for the cache path to reduce the impact on
184 // filesystems which are slow for large directories. Let N be adjustable.
185 const char *s_n
= getenv("SYSTEMTAP_NLEVELS");
189 if (nlevels
< 1) nlevels
= 1;
190 if (nlevels
> 8) nlevels
= 8;
193 hashdir
= s
.cache_path
;
195 for (int i
= 0; i
< nlevels
; i
++)
197 hashdir
+= string("/") + result
[i
*2] + result
[i
*2 + 1];
198 if (create_dir(hashdir
.c_str()) != 0)
200 s
.print_warning("failed to create cache directory (\"" + hashdir
+ "\") " + strerror(errno
) + ", disabling cache support");
201 s
.use_cache
= s
.use_script_cache
= false;
210 find_script_hash (systemtap_session
& s
, const string
& script
)
212 stap_hash
h(get_base_hash(s
));
214 // Hash getuid. This really shouldn't be necessary (since who you
215 // are doesn't change the generated output), but the hash gets used
216 // as the module name. If two different users try to run the same
217 // script at the same time, we need something to differentiate the
219 h
.add("UID: ", getuid());
221 // Hash user-specified arguments (that change the generated module).
222 h
.add("Bulk Mode (-b): ", s
.bulk_mode
);
223 h
.add("Timing (-t): ", s
.timing
);
224 h
.add("Prologue Searching (-P): ", s
.prologue_searching
);
225 h
.add("Skip Badvars (--skip-badvars): ", s
.skip_badvars
);
226 h
.add("Privilege (--privilege): ", s
.privilege
);
227 h
.add("Compatible (--compatible): ", s
.compatible
);
228 h
.add("Omit Werror (undocumented): ", s
.omit_werror
);
229 h
.add("Prologue Searching (-P): ", s
.prologue_searching
);
230 h
.add("Error suppression (--suppress-handler-errors): ", s
.suppress_handler_errors
);
231 h
.add("Suppress Time Limits (--suppress-time-limits): ", s
.suppress_time_limits
);
232 for (unsigned i
= 0; i
< s
.c_macros
.size(); i
++)
233 h
.add("Macros: ", s
.c_macros
[i
]);
235 // Add any custom kbuild flags (-B)
236 for (unsigned i
= 0; i
< s
.kbuildflags
.size(); i
++)
237 h
.add("Kbuildflags: ", s
.kbuildflags
[i
]);
239 // Add any custom --modinfo strings
240 for (unsigned i
= 0; i
< s
.modinfos
.size(); i
++)
241 h
.add("MODULE_INFO: ", s
.modinfos
[i
]);
244 for (set
<string
>::iterator it
= s
.unwindsym_modules
.begin();
245 it
!= s
.unwindsym_modules
.end();
247 h
.add_path("Unwindsym Modules ", *it
);
249 // Add the build id of each module
250 for(vector
<string
>::iterator it
= s
.build_ids
.begin();
251 it
!= s
.build_ids
.end();
253 h
.add("Build ID: ", *it
);
255 // Add in pass 2 script output.
256 h
.add("Script:\n", script
);
258 // Get the directory path to store our cached script
259 string result
, hashdir
;
261 if (!create_hashdir(s
, result
, hashdir
))
264 // Update module name to be 'stap_{hash start}'. '{hash start}'
265 // must not be too long. This shouldn't happen, since the maximum
266 // size of a hash is 32 fixed chars + 1 (for the '_') + a max of 11.
267 s
.module_name
= "stap_" + result
;
268 if (s
.module_name
.size() >= (MODULE_NAME_LEN
- 1))
269 s
.module_name
.resize(MODULE_NAME_LEN
- 1);
271 // 'ccache' would use a hash path of something like:
272 // s.hash_path = hashdir + "/" + result.substr(nlevels);
273 // which would look like:
274 // ~/.stap_cache/A/B/CDEFGHIJKLMNOPQRSTUVWXYZABCDEF_XXX
276 // We're using the following so that the module can be used straight
277 // from the cache if desired. This ends up looking like this:
278 // ~/.stap_cache/A/B/stap_ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEF_XXX.ko
279 s
.hash_path
= hashdir
+ "/" + s
.module_filename();
281 // Update C source name with new module_name.
282 s
.translated_source
= string(s
.tmpdir
) + "/" + s
.module_name
+ "_src.c";
283 create_hash_log(string("script_hash"), h
.get_parms(), result
,
284 hashdir
+ "/" + s
.module_name
+ "_hash.log");
289 find_stapconf_hash (systemtap_session
& s
)
291 stap_hash
h(get_base_hash(s
));
293 // Add any custom kbuild flags
294 for (unsigned i
= 0; i
< s
.kbuildflags
.size(); i
++)
295 h
.add("Kbuildflags: ", s
.kbuildflags
[i
]);
297 // Get the directory path to store our cached stapconf parameters
298 string result
, hashdir
;
300 if (!create_hashdir(s
, result
, hashdir
))
303 s
.stapconf_name
= "stapconf_" + result
+ ".h";
304 s
.stapconf_path
= hashdir
+ "/" + s
.stapconf_name
;
305 create_hash_log(string("stapconf_hash"), h
.get_parms(), result
,
306 hashdir
+ "/stapconf_" + result
+ "_hash.log");
311 find_tracequery_hash (systemtap_session
& s
, const string
& header
)
313 stap_hash
h(get_base_hash(s
));
315 // Add the tracepoint header to the computed hash
316 h
.add_path("Header ", header
);
318 // Add any custom kbuild flags
319 for (unsigned i
= 0; i
< s
.kbuildflags
.size(); i
++)
320 h
.add("Kbuildflags: ", s
.kbuildflags
[i
]);
322 // Get the directory path to store our cached module
323 string result
, hashdir
;
325 if (!create_hashdir(s
, result
, hashdir
))
326 return ""; // XXX: as opposed to throwing an exception?
328 create_hash_log(string("tracequery_hash"), h
.get_parms(), result
,
329 hashdir
+ "/tracequery_" + result
+ "_hash.log");
330 return hashdir
+ "/tracequery_" + result
+ ".o";
335 find_typequery_hash (systemtap_session
& s
, const string
& name
)
337 stap_hash
h(get_base_hash(s
));
339 // Add the typequery name to distinguish the hash
340 h
.add("Typequery Name: ", name
);
343 // Add any custom kbuild flags
344 for (unsigned i
= 0; i
< s
.kbuildflags
.size(); i
++)
345 h
.add("Kbuildflags: ", s
.kbuildflags
[i
]);
347 // Get the directory path to store our cached module
348 string result
, hashdir
;
350 if (!create_hashdir(s
, result
, hashdir
))
353 create_hash_log(string("typequery_hash"), h
.get_parms(), result
,
354 hashdir
+ "/typequery_" + result
+ "_hash.log");
355 return hashdir
+ "/typequery_" + result
356 + (name
[0] == 'k' ? ".ko" : ".so");
361 find_uprobes_hash (systemtap_session
& s
)
363 stap_hash
h(get_base_hash(s
));
365 // Hash runtime uprobes paths
366 h
.add_path("Uprobes Runtime Path /uprobes ", s
.runtime_path
+ "/linux/uprobes");
367 h
.add_path("Uprobes Runtime Path /uprobes2 ", s
.runtime_path
+ "/linux/uprobes2");
369 // Add any custom kbuild flags
370 for (unsigned i
= 0; i
< s
.kbuildflags
.size(); i
++)
371 h
.add("Kbuildflags: ", s
.kbuildflags
[i
]);
373 // Add any custom --modinfo strings
374 for (unsigned i
= 0; i
< s
.modinfos
.size(); i
++)
375 h
.add("MODULE_INFO: ", s
.modinfos
[i
]);
377 // Get the directory path to store our cached module
378 string result
, hashdir
;
380 if (!create_hashdir(s
, result
, hashdir
))
383 create_hash_log(string("uprobes_hash"), h
.get_parms(), result
,
384 hashdir
+ "/uprobes_" + result
+ "_hash.log");
385 return hashdir
+ "/uprobes_" + result
;
388 /* vim: set sw=2 ts=8 cino=>4,n-2,{2,^-2,t0,(0,u0,w1,M1 : */