[systemtap.git] / hash.cxx

// Copyright (C) Andrew Tridgell 2002 (original file)
// Copyright (C) 2006-2010 Red Hat Inc. (systemtap changes)
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

#include "config.h"
#include "session.h"
#include "hash.h"
#include "util.h"

#include <cstdlib>
#include <cstring>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <cerrno>

extern "C" {
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "mdfour.h"
}

using namespace std;


class hash
{
private:
  struct mdfour md4;
  std::ostringstream parm_stream;

public:
  hash() { start(); }
  hash(const hash &base) { md4 = base.md4; parm_stream << base.parm_stream.str(); }

  void start();

  void add(const unsigned char *buffer, size_t size);
  template<typename T> void add(const T& x);
  void add(const char *s) { add((const unsigned char *)s, strlen(s)); }
  void add(const std::string& s) { add((const unsigned char *)s.c_str(),
				       s.length()); }

  void add_path(const std::string& path);

  void result(std::string& r);
  std::string get_parms() { return parm_stream.str(); }
};


void
hash::start()
{
  mdfour_begin(&md4);
}


void
hash::add(const unsigned char *buffer, size_t size)
{
  parm_stream << buffer << endl;
  mdfour_update(&md4, buffer, size);
}


template <typename T> void
hash::add(const T& x)
{
  parm_stream << x << endl;
  mdfour_update(&md4, (const unsigned char *)&x, sizeof(x));
}


void
hash::add_path(const std::string& path)
{
  struct stat st;
  memset (&st, 0, sizeof(st));

  if (stat(path.c_str(), &st) != 0)
    st.st_size = st.st_mtime = -1;

  add(path);
  add(st.st_size);
  add(st.st_mtime);
}


void
hash::result(string& r)
{
  ostringstream rstream;
  unsigned char sum[16];

  mdfour_update(&md4, NULL, 0);
  mdfour_result(&md4, sum);

  for (int i=0; i<16; i++)
    {
      rstream << hex << setfill('0') << setw(2) << (unsigned)sum[i];
    }
  rstream << "_" << setw(0) << dec << (unsigned)md4.totalN;
  r = rstream.str();
}

void create_hash_log(const string &type_str, const string &parms, const string &result, const string &hash_log_path)
{
  ofstream log_file;
  time_t rawtime;
  time ( &rawtime );
  string time_str(ctime (&rawtime));

  log_file.open(hash_log_path.c_str());
  log_file << "[" << time_str.substr(0,time_str.length()-1); // erase terminated '\n'
  log_file << "] " << type_str << ":" << endl;
  log_file << parms << endl;
  log_file << _("result:") << result << endl;
  log_file.close();
}

static const hash&
get_base_hash (systemtap_session& s)
{
  if (s.base_hash)
    return *s.base_hash;

  s.base_hash = new hash();
  hash& h = *s.base_hash;

  // Hash kernel release and arch.
  h.add(s.kernel_release);
  h.add_path(s.kernel_build_tree);
  h.add(s.architecture);

  // Hash a few kernel version/build-id files too
  // (useful for kernel developers reusing a single source tree)
  h.add_path(s.kernel_build_tree + "/.config");
  h.add_path(s.kernel_build_tree + "/.version");
  h.add_path(s.kernel_build_tree + "/include/linux/compile.h");
  h.add_path(s.kernel_build_tree + "/include/linux/version.h");
  h.add_path(s.kernel_build_tree + "/include/linux/utsrelease.h");

  // If the kernel is a git working directory, then add the git HEAD
  // revision to our hash as well.
  // XXX avoiding this for now, because it's potentially expensive and has
  // uncertain gain.  The only corner case that this may help is if a developer
  // is switching the source tree without rebuilding the kernel...
  ///h.add(git_revision(s.kernel_build_tree));

  // Hash runtime path (that gets added in as "-R path").
  h.add_path(s.runtime_path);

  // Hash compiler path, size, and mtime.  We're just going to assume
  // we'll be using gcc. XXX: getting kbuild to spit out out would be
  // better, especially since this is fooled by ccache.
  h.add_path(find_executable("gcc"));

  // Hash the systemtap size and mtime.  We could use VERSION/DATE,
  // but when developing systemtap that doesn't work well (since you
  // can compile systemtap multiple times in 1 day).  Since we don't
  // know exactly where we're getting run from, we'll use
  // /proc/self/exe.
  // XXX well almost exactly -- valgrind throws this off
  h.add_path("/proc/self/exe");

  return h;
}


static bool
create_hashdir (systemtap_session& s, const string& result, string& hashdir)
{
  int nlevels = 1;

  // Use a N level subdir for the cache path to reduce the impact on
  // filesystems which are slow for large directories.  Let N be adjustable.
  const char *s_n = getenv("SYSTEMTAP_NLEVELS");
  if (s_n)
    {
      nlevels = atoi(s_n);
      if (nlevels < 1) nlevels = 1;
      if (nlevels > 8) nlevels = 8;
    }

  hashdir = s.cache_path;

  for (int i = 0; i < nlevels; i++)
    {
      hashdir += string("/") + result[i*2] + result[i*2 + 1];
      if (create_dir(hashdir.c_str()) != 0)
        {
          if (! s.suppress_warnings)
            cerr << autosprintf(_("Warning: failed to create cache directory (\"%s\") %s, disabling cache support"),
                                  hashdir.c_str(), strerror(errno)) << endl;
	  s.use_cache = s.use_script_cache = false;
	  return false;
	}
    }
  return true;
}


void
find_script_hash (systemtap_session& s, const string& script)
{
  hash h(get_base_hash(s));
  struct stat st;

  // Hash getuid.  This really shouldn't be necessary (since who you
  // are doesn't change the generated output), but the hash gets used
  // as the module name.  If two different users try to run the same
  // script at the same time, we need something to differentiate the
  // module name.
  h.add(getuid());

  // Hash user-specified arguments (that change the generated module).
  h.add(s.bulk_mode);			// '-b'
  h.add(s.timing);			// '-t'
  h.add(s.prologue_searching);		// '-P'
  h.add(s.ignore_vmlinux);		// --ignore-vmlinux
  h.add(s.ignore_dwarf);		// --ignore-dwarf
  h.add(s.consult_symtab);		// --kelf, --kmap
  h.add(s.skip_badvars);		// --skip-badvars
  h.add(s.unprivileged);		// --unprivileged
  h.add(s.compatible);			// --compatible
  h.add(s.omit_werror);		        // undocumented, evil
  if (!s.kernel_symtab_path.empty())	// --kmap
    {
      h.add(s.kernel_symtab_path);
      if (stat(s.kernel_symtab_path.c_str(), &st) == 0)
        {
	  // NB: stat of /proc/kallsyms always returns size=0, mtime=now...
	  // which is a good reason to use the default /boot/System.map-2.6.xx
	  // instead.
          h.add(st.st_size);
	  h.add(st.st_mtime);
        }
    }
  for (unsigned i = 0; i < s.macros.size(); i++)
    h.add(s.macros[i]);

  // Add any custom kbuild flags (-B)
  for (unsigned i = 0; i < s.kbuildflags.size(); i++)
    h.add(s.kbuildflags[i]);

  // -d MODULE
  for (set<string>::iterator it = s.unwindsym_modules.begin();
       it != s.unwindsym_modules.end();
       it++)
    h.add_path(*it);
    // XXX: a build-id of each module might be even better

  // Add in pass 2 script output.
  h.add(script);

  // Get the directory path to store our cached script
  string result, hashdir;
  h.result(result);
  if (!create_hashdir(s, result, hashdir))
    return;

  // Update module name to be 'stap_{hash start}'.  '{hash start}'
  // must not be too long.  This shouldn't happen, since the maximum
  // size of a hash is 32 fixed chars + 1 (for the '_') + a max of 11.
  s.module_name = "stap_" + result;
  if (s.module_name.size() >= (MODULE_NAME_LEN - 1))
    s.module_name.resize(MODULE_NAME_LEN - 1);

  // 'ccache' would use a hash path of something like:
  //    s.hash_path = hashdir + "/" + result.substr(nlevels);
  // which would look like:
  //    ~/.stap_cache/A/B/CDEFGHIJKLMNOPQRSTUVWXYZABCDEF_XXX
  //
  // We're using the following so that the module can be used straight
  // from the cache if desired.  This ends up looking like this:
  //    ~/.stap_cache/A/B/stap_ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEF_XXX.ko
  s.hash_path = hashdir + "/" + s.module_name + ".ko";

  // Update C source name with new module_name.
  s.translated_source = string(s.tmpdir) + "/" + s.module_name + ".c";
  create_hash_log(string("script_hash"), h.get_parms(), result,
                  hashdir + "/" + s.module_name + "_hash.log");
}


void
find_stapconf_hash (systemtap_session& s)
{
  hash h(get_base_hash(s));

  // Add any custom kbuild flags
  for (unsigned i = 0; i < s.kbuildflags.size(); i++)
    h.add(s.kbuildflags[i]);

  // Get the directory path to store our cached stapconf parameters
  string result, hashdir;
  h.result(result);
  if (!create_hashdir(s, result, hashdir))
    return;

  s.stapconf_name = "stapconf_" + result + ".h";
  s.stapconf_path = hashdir + "/" + s.stapconf_name;
  create_hash_log(string("stapconf_hash"), h.get_parms(), result,
                  hashdir + "/stapconf_" + result + "_hash.log");
}


string
find_tracequery_hash (systemtap_session& s, const vector<string>& headers)
{
  hash h(get_base_hash(s));

  // Add the tracepoint headers to the computed hash
  for (size_t i = 0; i < headers.size(); ++i)
    h.add_path(headers[i]);

  // Add any custom kbuild flags
  for (unsigned i = 0; i < s.kbuildflags.size(); i++)
    h.add(s.kbuildflags[i]);

  // Get the directory path to store our cached module
  string result, hashdir;
  h.result(result);
  if (!create_hashdir(s, result, hashdir))
    return "";

  create_hash_log(string("tracequery_hash"), h.get_parms(), result,
                  hashdir + "/tracequery_" + result + "_hash.log");
  return hashdir + "/tracequery_" + result + ".ko";
}


string
find_typequery_hash (systemtap_session& s, const string& name)
{
  hash h(get_base_hash(s));

  // Add the typequery name to distinguish the hash
  h.add(name);

  if (name[0] == 'k')
    // Add any custom kbuild flags
    for (unsigned i = 0; i < s.kbuildflags.size(); i++)
      h.add(s.kbuildflags[i]);

  // Get the directory path to store our cached module
  string result, hashdir;
  h.result(result);
  if (!create_hashdir(s, result, hashdir))
    return "";

  create_hash_log(string("typequery_hash"), h.get_parms(), result,
                  hashdir + "/typequery_" + result + "_hash.log");
  return hashdir + "/typequery_" + result
    + (name[0] == 'k' ? ".ko" : ".so");
}

/* vim: set sw=2 ts=8 cino=>4,n-2,{2,^-2,t0,(0,u0,w1,M1 : */
Commit	Line	Data
1b78aef5	1	// Copyright (C) Andrew Tridgell 2002 (original file)
dd936721	2	// Copyright (C) 2006-2010 Red Hat Inc. (systemtap changes)
dff50e09	3	//
1b78aef5 DS	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.
dff50e09	8	//
1b78aef5 DS	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.
dff50e09	13	//
1b78aef5 DS	14	// You should have received a copy of the GNU General Public License
	15	// along with this program; if not, write to the Free Software
	16	// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	17
	18	#include "config.h"
	19	#include "session.h"
	20	#include "hash.h"
	21	#include "util.h"
3b579393 FCE	22
3b579393 FCE	23	#include <cstdlib>
dd936721 JS	24	#include <cstring>
dd936721 JS	25	#include <fstream>
1b78aef5 DS	26	#include <sstream>
	27	#include <iomanip>
	28	#include <cerrno>
	29
	30	extern "C" {
	31	#include <sys/types.h>
	32	#include <sys/stat.h>
	33	#include <unistd.h>
dd936721	34	#include "mdfour.h"
1b78aef5 DS	35	}
	36
	37	using namespace std;
	38
dd936721 JS	39
	40	class hash
	41	{
	42	private:
	43	struct mdfour md4;
	44	std::ostringstream parm_stream;
	45
	46	public:
	47	hash() { start(); }
	48	hash(const hash &base) { md4 = base.md4; parm_stream << base.parm_stream.str(); }
	49
	50	void start();
	51
	52	void add(const unsigned char *buffer, size_t size);
9beca2c0	53	template<typename T> void add(const T& x);
dd936721 JS	54	void add(const char s) { add((const unsigned char )s, strlen(s)); }
	55	void add(const std::string& s) { add((const unsigned char *)s.c_str(),
	56	s.length()); }
9beca2c0	57
413c55ed	58	void add_path(const std::string& path);
dd936721 JS	59
dd936721 JS	60	void result(std::string& r);
178b5ebc	61	std::string get_parms() { return parm_stream.str(); }
dd936721 JS	62	};
	63
	64
1b78aef5 DS	65	void
	66	hash::start()
	67	{
	68	mdfour_begin(&md4);
	69	}
	70
	71
	72	void
	73	hash::add(const unsigned char *buffer, size_t size)
	74	{
178b5ebc	75	parm_stream << buffer << endl;
1b78aef5 DS	76	mdfour_update(&md4, buffer, size);
	77	}
	78
	79
9beca2c0 JS	80	template <typename T> void
	81	hash::add(const T& x)
	82	{
178b5ebc	83	parm_stream << x << endl;
9beca2c0 JS	84	mdfour_update(&md4, (const unsigned char *)&x, sizeof(x));
	85	}
	86
	87
2a8c27f6	88	void
413c55ed	89	hash::add_path(const std::string& path)
2a8c27f6 JS	90	{
2a8c27f6 JS	91	struct stat st;
e7899657	92	memset (&st, 0, sizeof(st));
2a8c27f6	93
413c55ed	94	if (stat(path.c_str(), &st) != 0)
9a193b06 JS	95	st.st_size = st.st_mtime = -1;
9a193b06 JS	96
413c55ed	97	add(path);
9a193b06 JS	98	add(st.st_size);
9a193b06 JS	99	add(st.st_mtime);
2a8c27f6 JS	100	}
	101
	102
1b78aef5 DS	103	void
	104	hash::result(string& r)
	105	{
	106	ostringstream rstream;
	107	unsigned char sum[16];
	108
	109	mdfour_update(&md4, NULL, 0);
	110	mdfour_result(&md4, sum);
	111
	112	for (int i=0; i<16; i++)
	113	{
	114	rstream << hex << setfill('0') << setw(2) << (unsigned)sum[i];
	115	}
	116	rstream << "_" << setw(0) << dec << (unsigned)md4.totalN;
	117	r = rstream.str();
	118	}
	119
0d1ad607 WH	120	void create_hash_log(const string &type_str, const string &parms, const string &result, const string &hash_log_path)
	121	{
	122	ofstream log_file;
	123	time_t rawtime;
	124	time ( &rawtime );
	125	string time_str(ctime (&rawtime));
	126
	127	log_file.open(hash_log_path.c_str());
	128	log_file << "[" << time_str.substr(0,time_str.length()-1); // erase terminated '\n'
178b5ebc JS	129	log_file << "] " << type_str << ":" << endl;
178b5ebc JS	130	log_file << parms << endl;
659d42ce	131	log_file << _("result:") << result << endl;
0d1ad607 WH	132	log_file.close();
0d1ad607 WH	133	}
1b78aef5	134
9b3c54b2 JS	135	static const hash&
9b3c54b2 JS	136	get_base_hash (systemtap_session& s)
1b78aef5	137	{
9b3c54b2 JS	138	if (s.base_hash)
	139	return *s.base_hash;
	140
	141	s.base_hash = new hash();
	142	hash& h = *s.base_hash;
	143
5c54d49e JS	144	// Hash kernel release and arch.
5c54d49e JS	145	h.add(s.kernel_release);
413c55ed	146	h.add_path(s.kernel_build_tree);
5c54d49e JS	147	h.add(s.architecture);
5c54d49e JS	148
2a8c27f6 JS	149	// Hash a few kernel version/build-id files too
2a8c27f6 JS	150	// (useful for kernel developers reusing a single source tree)
413c55ed JS	151	h.add_path(s.kernel_build_tree + "/.config");
	152	h.add_path(s.kernel_build_tree + "/.version");
	153	h.add_path(s.kernel_build_tree + "/include/linux/compile.h");
	154	h.add_path(s.kernel_build_tree + "/include/linux/version.h");
	155	h.add_path(s.kernel_build_tree + "/include/linux/utsrelease.h");
2a8c27f6	156
a5e8d632 JS	157	// If the kernel is a git working directory, then add the git HEAD
a5e8d632 JS	158	// revision to our hash as well.
d0d806ed JS	159	// XXX avoiding this for now, because it's potentially expensive and has
	160	// uncertain gain. The only corner case that this may help is if a developer
	161	// is switching the source tree without rebuilding the kernel...
	162	///h.add(git_revision(s.kernel_build_tree));
a5e8d632	163
5c54d49e	164	// Hash runtime path (that gets added in as "-R path").
413c55ed	165	h.add_path(s.runtime_path);
5c54d49e JS	166
	167	// Hash compiler path, size, and mtime. We're just going to assume
	168	// we'll be using gcc. XXX: getting kbuild to spit out out would be
413c55ed JS	169	// better, especially since this is fooled by ccache.
413c55ed JS	170	h.add_path(find_executable("gcc"));
5c54d49e JS	171
	172	// Hash the systemtap size and mtime. We could use VERSION/DATE,
	173	// but when developing systemtap that doesn't work well (since you
	174	// can compile systemtap multiple times in 1 day). Since we don't
	175	// know exactly where we're getting run from, we'll use
	176	// /proc/self/exe.
413c55ed JS	177	// XXX well almost exactly -- valgrind throws this off
413c55ed JS	178	h.add_path("/proc/self/exe");
9b3c54b2 JS	179
9b3c54b2 JS	180	return h;
5c54d49e JS	181	}
	182
	183
	184	static bool
	185	create_hashdir (systemtap_session& s, const string& result, string& hashdir)
	186	{
	187	int nlevels = 1;
	188
	189	// Use a N level subdir for the cache path to reduce the impact on
	190	// filesystems which are slow for large directories. Let N be adjustable.
	191	const char *s_n = getenv("SYSTEMTAP_NLEVELS");
	192	if (s_n)
1b78aef5 DS	193	{
	194	nlevels = atoi(s_n);
	195	if (nlevels < 1) nlevels = 1;
	196	if (nlevels > 8) nlevels = 8;
	197	}
	198
5c54d49e JS	199	hashdir = s.cache_path;
	200
	201	for (int i = 0; i < nlevels; i++)
	202	{
	203	hashdir += string("/") + result[i2] + result[i2 + 1];
	204	if (create_dir(hashdir.c_str()) != 0)
	205	{
	206	if (! s.suppress_warnings)
659d42ce LB	207	cerr << autosprintf(_("Warning: failed to create cache directory (\"%s\") %s, disabling cache support"),
659d42ce LB	208	hashdir.c_str(), strerror(errno)) << endl;
63d530ab	209	s.use_cache = s.use_script_cache = false;
5c54d49e JS	210	return false;
	211	}
	212	}
	213	return true;
	214	}
	215
	216
9b3c54b2 JS	217	void
9b3c54b2 JS	218	find_script_hash (systemtap_session& s, const string& script)
5c54d49e	219	{
9b3c54b2	220	hash h(get_base_hash(s));
5c54d49e JS	221	struct stat st;
5c54d49e JS	222
1b78aef5 DS	223	// Hash getuid. This really shouldn't be necessary (since who you
	224	// are doesn't change the generated output), but the hash gets used
	225	// as the module name. If two different users try to run the same
	226	// script at the same time, we need something to differentiate the
	227	// module name.
	228	h.add(getuid());
	229
1b78aef5	230	// Hash user-specified arguments (that change the generated module).
9c66f4e0	231	h.add(s.bulk_mode); // '-b'
9c66f4e0	232	h.add(s.timing); // '-t'
44f75386	233	h.add(s.prologue_searching); // '-P'
5f0a03a6 JK	234	h.add(s.ignore_vmlinux); // --ignore-vmlinux
	235	h.add(s.ignore_dwarf); // --ignore-dwarf
	236	h.add(s.consult_symtab); // --kelf, --kmap
dcfd7fed	237	h.add(s.skip_badvars); // --skip-badvars
df56da84	238	h.add(s.unprivileged); // --unprivileged
e1704764	239	h.add(s.compatible); // --compatible
d6c27347	240	h.add(s.omit_werror); // undocumented, evil
5f0a03a6 JK	241	if (!s.kernel_symtab_path.empty()) // --kmap
	242	{
	243	h.add(s.kernel_symtab_path);
	244	if (stat(s.kernel_symtab_path.c_str(), &st) == 0)
	245	{
	246	// NB: stat of /proc/kallsyms always returns size=0, mtime=now...
	247	// which is a good reason to use the default /boot/System.map-2.6.xx
	248	// instead.
	249	h.add(st.st_size);
	250	h.add(st.st_mtime);
	251	}
	252	}
1b78aef5 DS	253	for (unsigned i = 0; i < s.macros.size(); i++)
	254	h.add(s.macros[i]);
	255
4569f6bb	256	// Add any custom kbuild flags (-B)
1392896d FCE	257	for (unsigned i = 0; i < s.kbuildflags.size(); i++)
	258	h.add(s.kbuildflags[i]);
	259
a7f52597 FCE	260	// -d MODULE
	261	for (set<string>::iterator it = s.unwindsym_modules.begin();
	262	it != s.unwindsym_modules.end();
	263	it++)
2ccb4199	264	h.add_path(*it);
a7f52597 FCE	265	// XXX: a build-id of each module might be even better
a7f52597 FCE	266
1b78aef5 DS	267	// Add in pass 2 script output.
	268	h.add(script);
	269
5c54d49e JS	270	// Get the directory path to store our cached script
5c54d49e JS	271	string result, hashdir;
1b78aef5	272	h.result(result);
5c54d49e JS	273	if (!create_hashdir(s, result, hashdir))
5c54d49e JS	274	return;
1b78aef5 DS	275
	276	// Update module name to be 'stap_{hash start}'. '{hash start}'
	277	// must not be too long. This shouldn't happen, since the maximum
	278	// size of a hash is 32 fixed chars + 1 (for the '_') + a max of 11.
	279	s.module_name = "stap_" + result;
	280	if (s.module_name.size() >= (MODULE_NAME_LEN - 1))
	281	s.module_name.resize(MODULE_NAME_LEN - 1);
	282
	283	// 'ccache' would use a hash path of something like:
	284	// s.hash_path = hashdir + "/" + result.substr(nlevels);
	285	// which would look like:
	286	// ~/.stap_cache/A/B/CDEFGHIJKLMNOPQRSTUVWXYZABCDEF_XXX
	287	//
	288	// We're using the following so that the module can be used straight
	289	// from the cache if desired. This ends up looking like this:
	290	// ~/.stap_cache/A/B/stap_ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEF_XXX.ko
	291	s.hash_path = hashdir + "/" + s.module_name + ".ko";
	292
	293	// Update C source name with new module_name.
	294	s.translated_source = string(s.tmpdir) + "/" + s.module_name + ".c";
0d1ad607 WH	295	create_hash_log(string("script_hash"), h.get_parms(), result,
0d1ad607 WH	296	hashdir + "/" + s.module_name + "_hash.log");
1b78aef5	297	}
73267b89	298
5c54d49e	299
9b3c54b2 JS	300	void
9b3c54b2 JS	301	find_stapconf_hash (systemtap_session& s)
5c54d49e	302	{
9b3c54b2	303	hash h(get_base_hash(s));
5c54d49e	304
4569f6bb JS	305	// Add any custom kbuild flags
	306	for (unsigned i = 0; i < s.kbuildflags.size(); i++)
	307	h.add(s.kbuildflags[i]);
5c54d49e JS	308
	309	// Get the directory path to store our cached stapconf parameters
	310	string result, hashdir;
	311	h.result(result);
	312	if (!create_hashdir(s, result, hashdir))
	313	return;
	314
de0db58a JS	315	s.stapconf_name = "stapconf_" + result + ".h";
de0db58a JS	316	s.stapconf_path = hashdir + "/" + s.stapconf_name;
0d1ad607 WH	317	create_hash_log(string("stapconf_hash"), h.get_parms(), result,
0d1ad607 WH	318	hashdir + "/stapconf_" + result + "_hash.log");
5c54d49e JS	319	}
	320
	321
a2639cb7	322	string
55e50c24	323	find_tracequery_hash (systemtap_session& s, const vector<string>& headers)
b278033a	324	{
9b3c54b2	325	hash h(get_base_hash(s));
b278033a	326
55e50c24 JS	327	// Add the tracepoint headers to the computed hash
55e50c24 JS	328	for (size_t i = 0; i < headers.size(); ++i)
413c55ed	329	h.add_path(headers[i]);
b278033a	330
4569f6bb JS	331	// Add any custom kbuild flags
	332	for (unsigned i = 0; i < s.kbuildflags.size(); i++)
	333	h.add(s.kbuildflags[i]);
	334
b278033a JS	335	// Get the directory path to store our cached module
	336	string result, hashdir;
	337	h.result(result);
	338	if (!create_hashdir(s, result, hashdir))
a2639cb7	339	return "";
b278033a	340
0d1ad607 WH	341	create_hash_log(string("tracequery_hash"), h.get_parms(), result,
0d1ad607 WH	342	hashdir + "/tracequery_" + result + "_hash.log");
a2639cb7	343	return hashdir + "/tracequery_" + result + ".ko";
b278033a JS	344	}
b278033a JS	345
1f329b5e	346
a2639cb7 JS	347	string
a2639cb7 JS	348	find_typequery_hash (systemtap_session& s, const string& name)
1f329b5e	349	{
9b3c54b2	350	hash h(get_base_hash(s));
1f329b5e JS	351
	352	// Add the typequery name to distinguish the hash
	353	h.add(name);
	354
4569f6bb JS	355	if (name[0] == 'k')
	356	// Add any custom kbuild flags
	357	for (unsigned i = 0; i < s.kbuildflags.size(); i++)
	358	h.add(s.kbuildflags[i]);
	359
1f329b5e JS	360	// Get the directory path to store our cached module
	361	string result, hashdir;
	362	h.result(result);
	363	if (!create_hashdir(s, result, hashdir))
a2639cb7	364	return "";
1f329b5e	365
0d1ad607 WH	366	create_hash_log(string("typequery_hash"), h.get_parms(), result,
0d1ad607 WH	367	hashdir + "/typequery_" + result + "_hash.log");
a2639cb7	368	return hashdir + "/typequery_" + result
1f329b5e JS	369	+ (name[0] == 'k' ? ".ko" : ".so");
	370	}
	371
73267b89	372	/* vim: set sw=2 ts=8 cino=>4,n-2,{2,^-2,t0,(0,u0,w1,M1 : */