buildrun.cxx

   1 // build/run probes
   2 // Copyright (C) 2005-2012 Red Hat Inc.
   3 //
   4 // This file is part of systemtap, and is free software.  You can
   5 // redistribute it and/or modify it under the terms of the GNU General
   6 // Public License (GPL); either version 2, or (at your option) any
   7 // later version.
   8
   9 #include "config.h"
  10 #include "buildrun.h"
  11 #include "session.h"
  12 #include "util.h"
  13 #include "hash.h"
  14 #include "translate.h"
  15
  16 #include <cstdlib>
  17 #include <fstream>
  18 #include <sstream>
  19
  20 extern "C" {
  21 #include <signal.h>
  22 #include <sys/wait.h>
  23 #include <pwd.h>
  24 #include <grp.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <unistd.h>
  28 #include <string.h>
  29 #include <errno.h>
  30 }
  31
  32
  33 using namespace std;
  34
  35 /* Adjust and run make_cmd to build a kernel module. */
  36 static int
  37 run_make_cmd(systemtap_session& s, vector<string>& make_cmd,
  38              bool null_out=false, bool null_err=false)
  39 {
  40   assert_no_interrupts();
  41
  42   // PR14168: we used to unsetenv values here; instead do it via
  43   // env(1) in make_any_make_cmd().
  44
  45   // Disable ccache to avoid saving files that will never be reused.
  46   // (ccache is useless to us, because our compiler commands always
  47   // include the randomized tmpdir path.)
  48   // It's not critical if this fails, so the return is ignored.
  49   (void) setenv("CCACHE_DISABLE", "1", 0);
  50
  51   if (s.verbose > 2)
  52     make_cmd.push_back("V=1");
  53   else if (s.verbose > 1)
  54     make_cmd.push_back("--no-print-directory");
  55   else
  56     {
  57       make_cmd.push_back("-s");
  58       make_cmd.push_back("--no-print-directory");
  59     }
  60
  61   // Exploit SMP parallelism, if available.
  62   long smp = sysconf(_SC_NPROCESSORS_ONLN);
  63   if (smp >= 1)
  64     make_cmd.push_back("-j" + lex_cast(smp+1));
  65
  66   if (strverscmp (s.kernel_base_release.c_str(), "2.6.29") < 0)
  67     {
  68       // Older kernels, before linux commit #fd54f502841c1, include
  69       // gratuitous "echo"s in their Makefile.  We need to suppress
  70       // that with this bluntness.
  71       null_out = true;
  72     }
  73
  74   int rc = stap_system (s.verbose, "kbuild", make_cmd, null_out, null_err);
  75   if (rc != 0)
  76     s.set_try_server ();
  77   return rc;
  78 }
  79
  80 static vector<string>
  81 make_any_make_cmd(systemtap_session& s, const string& dir, const string& target)
  82 {
  83   vector<string> make_cmd;
  84
  85   // PR14168: sanitize environment variables for kbuild invocation
  86   make_cmd.push_back("env");
  87   make_cmd.push_back("-uARCH");
  88   make_cmd.push_back("-uKBUILD_EXTMOD");
  89   make_cmd.push_back("-uCROSS_COMPILE");
  90   make_cmd.push_back("-uKBUILD_IMAGE");
  91   make_cmd.push_back("-uKCONFIG_CONFIG");
  92   make_cmd.push_back("-uINSTALL_PATH");
  93   string newpath = string("PATH=/usr/bin:/bin:") + (getenv("PATH") ?: "");
  94   make_cmd.push_back(newpath.c_str());
  95
  96   make_cmd.push_back("make");
  97   make_cmd.push_back("-C");
  98   make_cmd.push_back(s.kernel_build_tree);
  99   make_cmd.push_back("M=" + dir); // need make-quoting?
 100   make_cmd.push_back(target);
 101
 102   // Add architecture, except for old powerpc (RHBZ669082)
 103   if (s.architecture != "powerpc" ||
 104       (strverscmp (s.kernel_base_release.c_str(), "2.6.15") >= 0))
 105     make_cmd.push_back("ARCH=" + s.architecture); // need make-quoting?
 106
 107   // PR13847: suppress debuginfo creation by default
 108   make_cmd.insert(make_cmd.end(), "CONFIG_DEBUG_INFO=");
 109
 110   // Add any custom kbuild flags
 111   make_cmd.insert(make_cmd.end(), s.kbuildflags.begin(), s.kbuildflags.end());
 112
 113   return make_cmd;
 114 }
 115
 116 static vector<string>
 117 make_make_cmd(systemtap_session& s, const string& dir)
 118 {
 119   return make_any_make_cmd(s, dir, "modules");
 120 }
 121
 122 static vector<string>
 123 make_make_objs_cmd(systemtap_session& s, const string& dir)
 124 {
 125   // Kbuild uses these rules to build external modules:
 126   //
 127   //   module-dirs := $(addprefix _module_,$(KBUILD_EXTMOD))
 128   //   modules: $(module-dirs)
 129   //       @$(kecho) '  Building modules, stage 2.';
 130   //       $(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost
 131   //
 132   // So if we're only interested in the stage 1 objects, we can
 133   // cheat and make only the $(module-dirs) part.
 134   return make_any_make_cmd(s, dir, "_module_" + dir);
 135 }
 136
 137 static void
 138 output_autoconf(systemtap_session& s, ofstream& o, const char *autoconf_c,
 139                 const char *deftrue, const char *deffalse)
 140 {
 141   o << "\t";
 142   if (s.verbose < 4)
 143     o << "@";
 144   o << "if $(CHECK_BUILD) $(SYSTEMTAP_RUNTIME)/linux/" << autoconf_c;
 145   if (s.verbose < 5)
 146     o << " > /dev/null 2>&1";
 147   o << "; then ";
 148   if (deftrue)
 149     o << "echo \"#define " << deftrue << " 1\"";
 150   if (deffalse)
 151     o << "; else echo \"#define " << deffalse << " 1\"";
 152   o << "; fi >> $@" << endl;
 153 }
 154
 155
 156 void output_exportconf(systemtap_session& s, ofstream& o, const char *symbol,
 157                      const char *deftrue)
 158 {
 159   o << "\t";
 160   if (s.verbose < 4)
 161     o << "@";
 162   if (s.kernel_exports.find(symbol) != s.kernel_exports.end())
 163     o << "echo \"#define " << deftrue << " 1\"";
 164   o << ">> $@" << endl;
 165 }
 166
 167
 168 void output_dual_exportconf(systemtap_session& s, ofstream& o,
 169                             const char *symbol1, const char *symbol2,
 170                             const char *deftrue)
 171 {
 172   o << "\t";
 173   if (s.verbose < 4)
 174     o << "@";
 175   if (s.kernel_exports.find(symbol1) != s.kernel_exports.end()
 176       && s.kernel_exports.find(symbol2) != s.kernel_exports.end())
 177     o << "echo \"#define " << deftrue << " 1\"";
 178   o << ">> $@" << endl;
 179 }
 180
 181
 182 void output_either_exportconf(systemtap_session& s, ofstream& o,
 183                               const char *symbol1, const char *symbol2,
 184                               const char *deftrue)
 185 {
 186   o << "\t";
 187   if (s.verbose < 4)
 188     o << "@";
 189   if (s.kernel_exports.find(symbol1) != s.kernel_exports.end()
 190       || s.kernel_exports.find(symbol2) != s.kernel_exports.end())
 191     o << "echo \"#define " << deftrue << " 1\"";
 192   o << ">> $@" << endl;
 193 }
 194
 195
 196 static int
 197 compile_dyninst (systemtap_session& s)
 198 {
 199   const string module = s.tmpdir + "/" + s.module_filename();
 200
 201   vector<string> cmd;
 202   cmd.push_back("gcc");
 203   cmd.push_back("--std=gnu99");
 204   cmd.push_back("-Wall");
 205   cmd.push_back("-Werror");
 206   cmd.push_back("-Wno-unused");
 207   cmd.push_back("-Wno-strict-aliasing");
 208   cmd.push_back("-O2");
 209   cmd.push_back("-I" + s.runtime_path);
 210   cmd.push_back("-D__DYNINST__");
 211   for (size_t i = 0; i < s.c_macros.size(); ++i)
 212     cmd.push_back("-D" + s.c_macros[i]);
 213   cmd.push_back(s.translated_source);
 214   cmd.push_back("-pthread");
 215   cmd.push_back("-lrt");
 216   cmd.push_back("-fPIC");
 217   cmd.push_back("-shared");
 218   cmd.push_back("-o");
 219   cmd.push_back(module);
 220   if (s.verbose > 3)
 221     {
 222       cmd.push_back("-ftime-report");
 223       cmd.push_back("-Q");
 224     }
 225
 226   int rc = stap_system (s.verbose, cmd);
 227   if (rc)
 228     s.set_try_server ();
 229   return rc;
 230 }
 231
 232
 233 int
 234 compile_pass (systemtap_session& s)
 235 {
 236   if (s.runtime_usermode_p())
 237     return compile_dyninst (s);
 238
 239   int rc = uprobes_pass (s);
 240   if (rc)
 241     {
 242       s.set_try_server ();
 243       return rc;
 244     }
 245
 246   // fill in a quick Makefile
 247   string makefile_nm = s.tmpdir + "/Makefile";
 248   ofstream o (makefile_nm.c_str());
 249
 250   // Create makefile
 251
 252   // Clever hacks copied from vmware modules
 253   string superverbose;
 254   if (s.verbose > 3)
 255     superverbose = "set -x;";
 256
 257   string redirecterrors = "> /dev/null 2>&1";
 258   if (s.verbose > 6)
 259     redirecterrors = "";
 260
 261   // Support O= (or KBUILD_OUTPUT) option
 262   o << "_KBUILD_CFLAGS := $(call flags,KBUILD_CFLAGS)" << endl;
 263
 264   o << "stap_check_gcc = $(shell " << superverbose << " if $(CC) $(1) -S -o /dev/null -xc /dev/null > /dev/null 2>&1; then echo \"$(1)\"; else echo \"$(2)\"; fi)" << endl;
 265   o << "CHECK_BUILD := $(CC) $(NOSTDINC_FLAGS) $(KBUILD_CPPFLAGS) $(CPPFLAGS) $(LINUXINCLUDE) $(_KBUILD_CFLAGS) $(CFLAGS_KERNEL) $(EXTRA_CFLAGS) $(CFLAGS) -DKBUILD_BASENAME=\\\"" << s.module_name << "\\\"" << (s.omit_werror ? "" : " -Werror") << " -S -o /dev/null -xc " << endl;
 266   o << "stap_check_build = $(shell " << superverbose << " if $(CHECK_BUILD) $(1) " << redirecterrors << " ; then echo \"$(2)\"; else echo \"$(3)\"; fi)" << endl;
 267
 268   o << "SYSTEMTAP_RUNTIME = \"" << s.runtime_path << "\"" << endl;
 269
 270   // "autoconf" options go here
 271
 272   // RHBZ 543529: early rhel6 kernels' module-signing kbuild logic breaks out-of-tree modules
 273   o << "CONFIG_MODULE_SIG := n" << endl;
 274
 275   string module_cflags = "EXTRA_CFLAGS";
 276   o << module_cflags << " :=" << endl;
 277
 278   // XXX: This gruesome hack is needed on some kernels built with separate O=directory,
 279   // where files like 2.6.27 x86's asm/mach-*/mach_mpspec.h are not found on the cpp path.
 280   // This could be a bug in arch/x86/Makefile that names
 281   //      mflags-y += -Iinclude/asm-x86/mach-default
 282   // but that path does not exist in an O= build tree.
 283   o << module_cflags << " += -Iinclude2/asm/mach-default" << endl;
 284   if (s.kernel_source_tree != "")
 285     o << module_cflags << " += -I" + s.kernel_source_tree << endl;
 286
 287   // NB: don't try
 288   // o << module_cflags << " += -Iusr/include" << endl;
 289   // since such headers are cleansed of _KERNEL_ pieces that we need
 290
 291   o << "STAPCONF_HEADER := " << s.tmpdir << "/" << s.stapconf_name << endl;
 292   o << "$(STAPCONF_HEADER):" << endl;
 293   o << "\t@echo -n > $@" << endl;
 294   output_autoconf(s, o, "autoconf-hrtimer-rel.c", "STAPCONF_HRTIMER_REL", NULL);
 295   output_autoconf(s, o, "autoconf-generated-compile.c", "STAPCONF_GENERATED_COMPILE", NULL);
 296   output_autoconf(s, o, "autoconf-hrtimer-getset-expires.c", "STAPCONF_HRTIMER_GETSET_EXPIRES", NULL);
 297   output_autoconf(s, o, "autoconf-inode-private.c", "STAPCONF_INODE_PRIVATE", NULL);
 298   output_autoconf(s, o, "autoconf-constant-tsc.c", "STAPCONF_CONSTANT_TSC", NULL);
 299   output_autoconf(s, o, "autoconf-ktime-get-real.c", "STAPCONF_KTIME_GET_REAL", NULL);
 300   output_autoconf(s, o, "autoconf-x86-uniregs.c", "STAPCONF_X86_UNIREGS", NULL);
 301   output_autoconf(s, o, "autoconf-nameidata.c", "STAPCONF_NAMEIDATA_CLEANUP", NULL);
 302   output_dual_exportconf(s, o, "unregister_kprobes", "unregister_kretprobes", "STAPCONF_UNREGISTER_KPROBES");
 303   output_autoconf(s, o, "autoconf-kprobe-symbol-name.c", "STAPCONF_KPROBE_SYMBOL_NAME", NULL);
 304   output_autoconf(s, o, "autoconf-real-parent.c", "STAPCONF_REAL_PARENT", NULL);
 305   output_autoconf(s, o, "autoconf-uaccess.c", "STAPCONF_LINUX_UACCESS_H", NULL);
 306   output_autoconf(s, o, "autoconf-oneachcpu-retry.c", "STAPCONF_ONEACHCPU_RETRY", NULL);
 307   output_autoconf(s, o, "autoconf-dpath-path.c", "STAPCONF_DPATH_PATH", NULL);
 308   output_exportconf(s, o, "synchronize_sched", "STAPCONF_SYNCHRONIZE_SCHED");
 309   output_autoconf(s, o, "autoconf-task-uid.c", "STAPCONF_TASK_UID", NULL);
 310   output_dual_exportconf(s, o, "alloc_vm_area", "free_vm_area", "STAPCONF_VM_AREA");
 311   output_autoconf(s, o, "autoconf-procfs-owner.c", "STAPCONF_PROCFS_OWNER", NULL);
 312   output_autoconf(s, o, "autoconf-alloc-percpu-align.c", "STAPCONF_ALLOC_PERCPU_ALIGN", NULL);
 313   output_autoconf(s, o, "autoconf-x86-gs.c", "STAPCONF_X86_GS", NULL);
 314   output_autoconf(s, o, "autoconf-grsecurity.c", "STAPCONF_GRSECURITY", NULL);
 315   output_autoconf(s, o, "autoconf-trace-printk.c", "STAPCONF_TRACE_PRINTK", NULL);
 316   output_autoconf(s, o, "autoconf-regset.c", "STAPCONF_REGSET", NULL);
 317   output_autoconf(s, o, "autoconf-utrace-regset.c", "STAPCONF_UTRACE_REGSET", NULL);
 318   output_autoconf(s, o, "autoconf-uprobe-get-pc.c", "STAPCONF_UPROBE_GET_PC", NULL);
 319   output_exportconf(s, o, "tsc_khz", "STAPCONF_TSC_KHZ");
 320   output_exportconf(s, o, "cpu_khz", "STAPCONF_CPU_KHZ");
 321   output_exportconf(s, o, "__module_text_address", "STAPCONF_MODULE_TEXT_ADDRESS");
 322   output_exportconf(s, o, "add_timer_on", "STAPCONF_ADD_TIMER_ON");
 323
 324   output_dual_exportconf(s, o, "probe_kernel_read", "probe_kernel_write", "STAPCONF_PROBE_KERNEL");
 325   output_autoconf(s, o, "autoconf-hw_breakpoint_context.c",
 326                   "STAPCONF_HW_BREAKPOINT_CONTEXT", NULL);
 327   output_autoconf(s, o, "autoconf-save-stack-trace.c",
 328                   "STAPCONF_KERNEL_STACKTRACE", NULL);
 329   output_autoconf(s, o, "autoconf-save-stack-trace-no-bp.c",
 330                   "STAPCONF_KERNEL_STACKTRACE_NO_BP", NULL);
 331   output_autoconf(s, o, "autoconf-asm-syscall.c",
 332                   "STAPCONF_ASM_SYSCALL_H", NULL);
 333   output_autoconf(s, o, "autoconf-ring_buffer-flags.c", "STAPCONF_RING_BUFFER_FLAGS", NULL);
 334   output_autoconf(s, o, "autoconf-ring_buffer_lost_events.c", "STAPCONF_RING_BUFFER_LOST_EVENTS", NULL);
 335   output_autoconf(s, o, "autoconf-ring_buffer_read_prepare.c", "STAPCONF_RING_BUFFER_READ_PREPARE", NULL);
 336   output_autoconf(s, o, "autoconf-kallsyms-on-each-symbol.c", "STAPCONF_KALLSYMS_ON_EACH_SYMBOL", NULL);
 337   output_autoconf(s, o, "autoconf-walk-stack.c", "STAPCONF_WALK_STACK", NULL);
 338   output_autoconf(s, o, "autoconf-stacktrace_ops-warning.c",
 339                   "STAPCONF_STACKTRACE_OPS_WARNING", NULL);
 340   output_autoconf(s, o, "autoconf-mm-context-vdso.c", "STAPCONF_MM_CONTEXT_VDSO", NULL);
 341   output_autoconf(s, o, "autoconf-mm-context-vdso-base.c", "STAPCONF_MM_CONTEXT_VDSO_BASE", NULL);
 342   output_autoconf(s, o, "autoconf-blk-types.c", "STAPCONF_BLK_TYPES", NULL);
 343   output_autoconf(s, o, "autoconf-perf-structpid.c", "STAPCONF_PERF_STRUCTPID", NULL);
 344   output_autoconf(s, o, "perf_event_counter_context.c",
 345                   "STAPCONF_PERF_COUNTER_CONTEXT", NULL);
 346   output_autoconf(s, o, "perf_probe_handler_nmi.c",
 347                   "STAPCONF_PERF_HANDLER_NMI", NULL);
 348   output_exportconf(s, o, "path_lookup", "STAPCONF_PATH_LOOKUP");
 349   output_exportconf(s, o, "kern_path_parent", "STAPCONF_KERN_PATH_PARENT");
 350   output_exportconf(s, o, "vfs_path_lookup", "STAPCONF_VFS_PATH_LOOKUP");
 351   output_autoconf(s, o, "autoconf-module-sect-attrs.c", "STAPCONF_MODULE_SECT_ATTRS", NULL);
 352
 353   output_autoconf(s, o, "autoconf-utrace-via-tracepoints.c", "STAPCONF_UTRACE_VIA_TRACEPOINTS", NULL);
 354   output_autoconf(s, o, "autoconf-task_work-struct.c", "STAPCONF_TASK_WORK_STRUCT", NULL);
 355   output_autoconf(s, o, "autoconf-vm-area-pte.c", "STAPCONF_VM_AREA_PTE", NULL);
 356   output_autoconf(s, o, "autoconf-relay-umode_t.c", "STAPCONF_RELAY_UMODE_T", NULL);
 357   output_autoconf(s, o, "autoconf-fs_supers-hlist.c", "STAPCONF_FS_SUPERS_HLIST", NULL);
 358
 359   // used by tapset/timestamp_monotonic.stp
 360   output_exportconf(s, o, "cpu_clock", "STAPCONF_CPU_CLOCK");
 361   output_exportconf(s, o, "local_clock", "STAPCONF_LOCAL_CLOCK");
 362
 363   // used by runtime/uprobe-inode.c
 364   output_either_exportconf(s, o, "uprobe_register", "register_uprobe",
 365                            "STAPCONF_UPROBE_REGISTER_EXPORTED");
 366   output_either_exportconf(s, o, "uprobe_unregister", "unregister_uprobe",
 367                            "STAPCONF_UPROBE_UNREGISTER_EXPORTED");
 368   output_autoconf(s, o, "autoconf-old-inode-uprobes.c", "STAPCONF_OLD_INODE_UPROBES", NULL);
 369
 370   // used by tapsets.cxx inode uprobe generated code
 371   output_exportconf(s, o, "uprobe_get_swbp_addr", "STAPCONF_UPROBE_GET_SWBP_ADDR_EXPORTED");
 372
 373   // used by runtime/loc2c-runtime.h
 374   output_exportconf(s, o, "task_user_regset_view", "STAPCONF_TASK_USER_REGSET_VIEW_EXPORTED");
 375
 376   // used by runtime/stp_utrace.c
 377   output_exportconf(s, o, "task_work_add", "STAPCONF_TASK_WORK_ADD_EXPORTED");
 378
 379   output_autoconf(s, o, "autoconf-pagefault_disable.c", "STAPCONF_PAGEFAULT_DISABLE", NULL);
 380   output_exportconf(s, o, "kallsyms_lookup_name", "STAPCONF_KALLSYMS");
 381
 382   o << module_cflags << " += -include $(STAPCONF_HEADER)" << endl;
 383
 384   for (unsigned i=0; i<s.c_macros.size(); i++)
 385     o << "EXTRA_CFLAGS += -D " << lex_cast_qstring(s.c_macros[i]) << endl; // XXX right quoting?
 386
 387   if (s.verbose > 3)
 388     o << "EXTRA_CFLAGS += -ftime-report -Q" << endl;
 389
 390   // XXX: unfortunately, -save-temps can't work since linux kbuild cwd
 391   // is not writable.
 392   //
 393   // if (s.keep_tmpdir)
 394   // o << "CFLAGS += -fverbose-asm -save-temps" << endl;
 395
 396   // Kernels can be compiled with CONFIG_CC_OPTIMIZE_FOR_SIZE to select
 397   // -Os, otherwise -O2 is the default.
 398   o << "EXTRA_CFLAGS += -freorder-blocks" << endl; // improve on -Os
 399
 400   // We used to allow the user to override default optimization when so
 401   // requested by adding a -O[0123s] so they could determine the
 402   // time/space/speed tradeoffs themselves, but we cannot guantantee that
 403   // the (un)optimized code actually compiles and/or generates functional
 404   // code, so we had to remove it.
 405   // o << "EXTRA_CFLAGS += " << s.gcc_flags << endl; // Add -O[0123s]
 406
 407   // o << "CFLAGS += -fno-unit-at-a-time" << endl;
 408
 409   // 256 bytes should be enough for anybody
 410   // XXX this doesn't validate varargs, per gcc bug #41633
 411   o << "EXTRA_CFLAGS += $(call cc-option,-Wframe-larger-than=256)" << endl;
 412
 413   // Assumes linux 2.6 kbuild
 414   o << "EXTRA_CFLAGS += -Wno-unused" << (s.omit_werror ? "" : " -Werror") << endl;
 415   #if CHECK_POINTER_ARITH_PR5947
 416   o << "EXTRA_CFLAGS += -Wpointer-arith" << endl;
 417   #endif
 418   o << "EXTRA_CFLAGS += -I\"" << s.runtime_path << "\"" << endl;
 419   // XXX: this may help ppc toc overflow
 420   // o << "CFLAGS := $(subst -Os,-O2,$(CFLAGS)) -fminimal-toc" << endl;
 421   o << "obj-m := " << s.module_name << ".o" << endl;
 422
 423   // print out all the auxiliary source (->object) file names
 424   o << s.module_name << "-y := ";
 425   for (unsigned i=0; i<s.auxiliary_outputs.size(); i++)
 426     {
 427       string srcname = s.auxiliary_outputs[i]->filename;
 428       assert (srcname != "" && srcname.rfind('/') != string::npos);
 429       string objname = srcname.substr(srcname.rfind('/')+1); // basename
 430       assert (objname != "" && objname[objname.size()-1] == 'c');
 431       objname[objname.size()-1] = 'o'; // now objname
 432       o << " " + objname;
 433     }
 434   // and once again, for the translated_source file.  It can't simply
 435   // be named MODULENAME.c, since kbuild doesn't allow a foo.ko file
 436   // consisting of multiple .o's to have foo.o/foo.c as a source.
 437   // (It uses ld -r -o foo.o EACH.o EACH.o).
 438   {
 439     string srcname = s.translated_source;
 440     assert (srcname != "" && srcname.rfind('/') != string::npos);
 441     string objname = srcname.substr(srcname.rfind('/')+1); // basename
 442     assert (objname != "" && objname[objname.size()-1] == 'c');
 443     objname[objname.size()-1] = 'o'; // now objname
 444     o << " " + objname;
 445   }
 446   o << endl;
 447
 448   // add all stapconf dependencies
 449   o << s.translated_source << ": $(STAPCONF_HEADER)" << endl;
 450   for (unsigned i=0; i<s.auxiliary_outputs.size(); i++)
 451     o << s.auxiliary_outputs[i]->filename << ": $(STAPCONF_HEADER)" << endl;
 452
 453
 454   o.close ();
 455
 456   // Generate module directory pathname and make sure it exists.
 457   string module_dir = s.kernel_build_tree;
 458   string module_dir_makefile = module_dir + "/Makefile";
 459   struct stat st;
 460   rc = stat(module_dir_makefile.c_str(), &st);
 461   if (rc != 0)
 462     {
 463         clog << _F("Checking \" %s \" failed with error: %s\nEnsure kernel development headers & makefiles are installed.",
 464                    module_dir_makefile.c_str(), strerror(errno)) << endl;
 465         s.set_try_server ();
 466         return rc;
 467     }
 468
 469   // Run make
 470   vector<string> make_cmd = make_make_cmd(s, s.tmpdir);
 471   rc = run_make_cmd(s, make_cmd);
 472   if (rc)
 473     s.set_try_server ();
 474   return rc;
 475 }
 476
 477 /*
 478  * If uprobes was built as part of the kernel build (either built-in
 479  * or as a module), the uprobes exports should show up.  This is to be
 480  * as distinct from the stap-built uprobes.ko from the runtime.
 481  */
 482 static bool
 483 kernel_built_uprobes (systemtap_session& s)
 484 {
 485   if (s.runtime_usermode_p())
 486     return true; // sort of, via dyninst
 487
 488   // see also tapsets.cxx:kernel_supports_inode_uprobes()
 489   return ((s.kernel_config["CONFIG_ARCH_SUPPORTS_UPROBES"] == "y" && s.kernel_config["CONFIG_UPROBES"] == "y") ||
 490           (s.kernel_exports.find("unregister_uprobe") != s.kernel_exports.end()));
 491 }
 492
 493 static int
 494 make_uprobes (systemtap_session& s)
 495 {
 496   if (s.verbose > 1)
 497     clog << _("Pass 4, preamble: (re)building SystemTap's version of uprobes.")
 498          << endl;
 499
 500   // create a subdirectory for the uprobes module
 501   string dir(s.tmpdir + "/uprobes");
 502   if (create_dir(dir.c_str()) != 0)
 503     {
 504       s.print_warning("failed to create directory for build uprobes.");
 505       s.set_try_server ();
 506       return 1;
 507     }
 508
 509   // create a simple Makefile
 510   string makefile(dir + "/Makefile");
 511   ofstream omf(makefile.c_str());
 512   omf << "obj-m := uprobes.o" << endl;
 513   // RHBZ 655231: later rhel6 kernels' module-signing kbuild logic breaks out-of-tree modules
 514   omf << "CONFIG_MODULE_SIG := n" << endl;
 515   omf.close();
 516
 517   // create a simple #include-chained source file
 518   string runtimesourcefile(s.runtime_path + "/linux/uprobes/uprobes.c");
 519   string sourcefile(dir + "/uprobes.c");
 520   ofstream osrc(sourcefile.c_str());
 521   osrc << "#include \"" << runtimesourcefile << "\"" << endl;
 522
 523   // pass --modinfo k=v to uprobes build too
 524   for (unsigned i = 0; i < s.modinfos.size(); i++)
 525     {
 526       const string& mi = s.modinfos[i];
 527       size_t loc = mi.find('=');
 528       string tag = mi.substr (0, loc);
 529       string value = mi.substr (loc+1);
 530       osrc << "MODULE_INFO(" << tag << "," << lex_cast_qstring(value) << ");" << endl;
 531     }
 532
 533   osrc.close();
 534
 535   // make the module
 536   vector<string> make_cmd = make_make_cmd(s, dir);
 537   int rc = run_make_cmd(s, make_cmd);
 538   if (!rc && !copy_file(dir + "/Module.symvers",
 539                         s.tmpdir + "/Module.symvers"))
 540     rc = -1;
 541
 542   if (s.verbose > 1)
 543     clog << _("uprobes rebuild exit code: ") << rc << endl;
 544   if (rc)
 545     s.set_try_server ();
 546   else
 547     s.uprobes_path = dir + "/uprobes.ko";
 548   return rc;
 549 }
 550
 551 static bool
 552 get_cached_uprobes(systemtap_session& s)
 553 {
 554   s.uprobes_hash = s.use_cache ? find_uprobes_hash(s) : "";
 555   if (!s.uprobes_hash.empty())
 556     {
 557       // NB: We always put uprobes.ko in its own directory, especially so
 558       // stap-serverd can more easily locate it.
 559       string dir(s.tmpdir + "/uprobes");
 560       if (create_dir(dir.c_str()) != 0)
 561         return false;
 562
 563       string cacheko = s.uprobes_hash + ".ko";
 564       string tmpko = dir + "/uprobes.ko";
 565
 566       // The symvers file still needs to go in the script module's directory.
 567       string cachesyms = s.uprobes_hash + ".symvers";
 568       string tmpsyms = s.tmpdir + "/Module.symvers";
 569
 570       if (get_file_size(cacheko) > 0 && copy_file(cacheko, tmpko) &&
 571           get_file_size(cachesyms) > 0 && copy_file(cachesyms, tmpsyms))
 572         {
 573           s.uprobes_path = tmpko;
 574           return true;
 575         }
 576     }
 577   return false;
 578 }
 579
 580 static void
 581 set_cached_uprobes(systemtap_session& s)
 582 {
 583   if (s.use_cache && !s.uprobes_hash.empty())
 584     {
 585       string cacheko = s.uprobes_hash + ".ko";
 586       string tmpko = s.tmpdir + "/uprobes/uprobes.ko";
 587       copy_file(tmpko, cacheko);
 588
 589       string cachesyms = s.uprobes_hash + ".symvers";
 590       string tmpsyms = s.tmpdir + "/uprobes/Module.symvers";
 591       copy_file(tmpsyms, cachesyms);
 592     }
 593 }
 594
 595 int
 596 uprobes_pass (systemtap_session& s)
 597 {
 598   if (!s.need_uprobes || kernel_built_uprobes(s))
 599     return 0;
 600
 601   if (s.kernel_config["CONFIG_UTRACE"] != string("y"))
 602     {
 603       clog << _("user-space facilities not available without kernel CONFIG_UTRACE or CONFIG_TRACEPOINTS/CONFIG_ARCH_SUPPORTS_UPROBES/CONFIG_UPROBES") << endl;
 604       s.set_try_server ();
 605       return 1;
 606     }
 607
 608   /*
 609    * We need to use the version of uprobes that comes with SystemTap.  Try to
 610    * get it from the cache first.  If not found, build it and try to save it to
 611    * the cache for future reuse.
 612    */
 613   int rc = 0;
 614   if (!get_cached_uprobes(s))
 615     {
 616       rc = make_uprobes(s);
 617       if (!rc)
 618         set_cached_uprobes(s);
 619     }
 620   if (rc)
 621     s.set_try_server ();
 622   return rc;
 623 }
 624
 625 static
 626 vector<string>
 627 make_dyninst_run_command (systemtap_session& s, const string& remotedir,
 628                           const string& version)
 629 {
 630   vector<string> cmd;
 631   cmd.push_back(getenv("SYSTEMTAP_STAPDYN") ?: BINDIR "/stapdyn");
 632
 633   // use slightly less verbosity
 634   for (unsigned i=1; i<s.verbose; i++)
 635     cmd.push_back("-v");
 636   if (s.suppress_warnings)
 637     cmd.push_back("-w");
 638
 639   if (!s.cmd.empty())
 640     {
 641       cmd.push_back("-c");
 642       cmd.push_back(s.cmd);
 643     }
 644
 645   cmd.push_back((remotedir.empty() ? s.tmpdir : remotedir)
 646                 + "/" + s.module_filename());
 647
 648   return cmd;
 649 }
 650
 651 vector<string>
 652 make_run_command (systemtap_session& s, const string& remotedir,
 653                   const string& version)
 654 {
 655   if (s.runtime_usermode_p())
 656     return make_dyninst_run_command(s, remotedir, version);
 657
 658   // for now, just spawn staprun
 659   vector<string> staprun_cmd;
 660   staprun_cmd.push_back(getenv("SYSTEMTAP_STAPRUN") ?: BINDIR "/staprun");
 661
 662   // use slightly less verbosity
 663   for (unsigned i=1; i<s.verbose; i++)
 664     staprun_cmd.push_back("-v");
 665   if (s.suppress_warnings)
 666     staprun_cmd.push_back("-w");
 667
 668   if (!s.output_file.empty())
 669     {
 670       staprun_cmd.push_back("-o");
 671       staprun_cmd.push_back(s.output_file);
 672     }
 673
 674   if (!s.cmd.empty())
 675     {
 676       staprun_cmd.push_back("-c");
 677       staprun_cmd.push_back(s.cmd);
 678     }
 679
 680   if (s.target_pid)
 681     {
 682       staprun_cmd.push_back("-t");
 683       staprun_cmd.push_back(lex_cast(s.target_pid));
 684     }
 685
 686   if (s.buffer_size)
 687     {
 688       staprun_cmd.push_back("-b");
 689       staprun_cmd.push_back(lex_cast(s.buffer_size));
 690     }
 691
 692   if (s.need_uprobes && !kernel_built_uprobes(s))
 693     {
 694       string opt_u = "-u";
 695       if (!s.uprobes_path.empty() &&
 696           strverscmp("1.4", version.c_str()) <= 0)
 697         {
 698           if (remotedir.empty())
 699             opt_u.append(s.uprobes_path);
 700           else
 701             opt_u.append(remotedir + "/" + basename(s.uprobes_path.c_str()));
 702         }
 703       staprun_cmd.push_back(opt_u);
 704     }
 705
 706   if (s.load_only)
 707     staprun_cmd.push_back(s.output_file.empty() ? "-L" : "-D");
 708
 709   if(!s.modname_given && (strverscmp("1.6", version.c_str()) <= 0))
 710     staprun_cmd.push_back("-R");
 711
 712   if (!s.size_option.empty())
 713     {
 714       staprun_cmd.push_back("-S");
 715       staprun_cmd.push_back(s.size_option);
 716     }
 717
 718   staprun_cmd.push_back((remotedir.empty() ? s.tmpdir : remotedir)
 719                         + "/" + s.module_filename());
 720
 721   // add module arguments
 722   staprun_cmd.insert(staprun_cmd.end(),
 723                      s.globalopts.begin(), s.globalopts.end());
 724
 725   return staprun_cmd;
 726 }
 727
 728
 729 // Build tiny kernel modules to query tracepoints.
 730 // Given a (header-file -> test-contents) map, compile them ASAP, and return
 731 // a (header-file -> obj-filename) map.
 732
 733 map<string,string>
 734 make_tracequeries(systemtap_session& s, const map<string,string>& contents)
 735 {
 736   static unsigned tick = 0;
 737   string basename("tracequery_kmod_" + lex_cast(++tick));
 738   map<string,string> objs;
 739
 740   // create a subdirectory for the module
 741   string dir(s.tmpdir + "/" + basename);
 742   if (create_dir(dir.c_str()) != 0)
 743     {
 744       s.print_warning("failed to create directory for querying tracepoints.");
 745       s.set_try_server ();
 746       return objs;
 747     }
 748
 749   // create a simple Makefile
 750   string makefile(dir + "/Makefile");
 751   ofstream omf(makefile.c_str());
 752   // force debuginfo generation, and relax implicit functions
 753   omf << "EXTRA_CFLAGS := -g -Wno-implicit-function-declaration" << (s.omit_werror ? "" : " -Werror") << endl;
 754   // RHBZ 655231: later rhel6 kernels' module-signing kbuild logic breaks out-of-tree modules
 755   omf << "CONFIG_MODULE_SIG := n" << endl;
 756
 757   if (s.kernel_source_tree != "")
 758     omf << "EXTRA_CFLAGS += -I" + s.kernel_source_tree << endl;
 759
 760   omf << "obj-m := " << endl;
 761   // write out each header-specific source file into a separate file
 762   for (map<string,string>::const_iterator it = contents.begin(); it != contents.end(); it++)
 763     {
 764       string sbasename = basename + "_" + lex_cast(++tick); // suffixed
 765
 766       // write out source code
 767       string srcname = dir + "/" + sbasename + ".c";
 768       string src = it->second;
 769       ofstream osrc(srcname.c_str());
 770       osrc << src;
 771       osrc.close();
 772
 773       // arrange to build it
 774       omf << "obj-m += " + sbasename + ".o" << endl; // NB: without <dir> prefix
 775       objs[it->first] = dir + "/" + sbasename + ".o";
 776     }
 777   omf.close();
 778
 779   // make the module
 780   vector<string> make_cmd = make_make_objs_cmd(s, dir);
 781   make_cmd.push_back ("-i"); // ignore errors, give rc 0 even in case of tracepoint header nits
 782   bool quiet = (s.verbose < 4);
 783   int rc = run_make_cmd(s, make_cmd, quiet, quiet);
 784   if (rc)
 785     s.set_try_server ();
 786
 787   // Sometimes we fail a tracequery due to PR9993 / PR11649 type
 788   // kernel trace header problems.  In this case, due to PR12729, we
 789   // used to get a lovely "Warning: make exited with status: 2" but no
 790   // other useful diagnostic.  -vvvv would let a user see what's up,
 791   // but the user can't fix the problem even with that.
 792
 793   return objs;
 794 }
 795
 796
 797 // Build a tiny kernel module to query type information
 798 static int
 799 make_typequery_kmod(systemtap_session& s, const vector<string>& headers, string& name)
 800 {
 801   static unsigned tick = 0;
 802   string basename("typequery_kmod_" + lex_cast(++tick));
 803
 804   // create a subdirectory for the module
 805   string dir(s.tmpdir + "/" + basename);
 806   if (create_dir(dir.c_str()) != 0)
 807     {
 808       s.print_warning("failed to create directory for querying types.");
 809       s.set_try_server ();
 810       return 1;
 811     }
 812
 813   name = dir + "/" + basename + ".ko";
 814
 815   // create a simple Makefile
 816   string makefile(dir + "/Makefile");
 817   ofstream omf(makefile.c_str());
 818   omf << "EXTRA_CFLAGS := -g -fno-eliminate-unused-debug-types" << endl;
 819
 820   // RHBZ 655231: later rhel6 kernels' module-signing kbuild logic breaks out-of-tree modules
 821   omf << "CONFIG_MODULE_SIG := n" << endl;
 822
 823   // NB: We use -include instead of #include because that gives us more power.
 824   // Using #include searches relative to the source's path, which in this case
 825   // is /tmp/..., so that's not helpful.  Using -include will search relative
 826   // to the cwd, which will be the kernel build root.  This means if you have a
 827   // full kernel build tree, it's possible to get at types that aren't in the
 828   // normal include path, e.g.:
 829   //    @cast(foo, "bsd_acct_struct", "kernel<kernel/acct.c>")->...
 830   omf << "CFLAGS_" << basename << ".o :=";
 831   for (size_t i = 0; i < headers.size(); ++i)
 832     omf << " -include " << lex_cast_qstring(headers[i]); // XXX right quoting?
 833   omf << endl;
 834
 835   omf << "obj-m := " + basename + ".o" << endl;
 836   omf.close();
 837
 838   // create our empty source file
 839   string source(dir + "/" + basename + ".c");
 840   ofstream osrc(source.c_str());
 841   osrc.close();
 842
 843   // make the module
 844   vector<string> make_cmd = make_make_cmd(s, dir);
 845   bool quiet = (s.verbose < 4);
 846   int rc = run_make_cmd(s, make_cmd, quiet, quiet);
 847   if (rc)
 848     s.set_try_server ();
 849   return rc;
 850 }
 851
 852
 853 // Build a tiny user module to query type information
 854 static int
 855 make_typequery_umod(systemtap_session& s, const vector<string>& headers, string& name)
 856 {
 857   static unsigned tick = 0;
 858
 859   name = s.tmpdir + "/typequery_umod_" + lex_cast(++tick) + ".so";
 860
 861   // make the module
 862   //
 863   // NB: As with kmod, using -include makes relative paths more useful.  The
 864   // cwd in this case will be the cwd of stap itself though, which may be
 865   // trickier to deal with.  It might be better to "cd `dirname $script`"
 866   // first...
 867   vector<string> cmd;
 868   cmd.push_back("gcc");
 869   cmd.push_back("-shared");
 870   cmd.push_back("-g");
 871   cmd.push_back("-fno-eliminate-unused-debug-types");
 872   cmd.push_back("-xc");
 873   cmd.push_back("/dev/null");
 874   cmd.push_back("-o");
 875   cmd.push_back(name);
 876   for (size_t i = 0; i < headers.size(); ++i)
 877     {
 878       cmd.push_back("-include");
 879       cmd.push_back(headers[i]);
 880     }
 881   bool quiet = (s.verbose < 4);
 882   int rc = stap_system (s.verbose, cmd, quiet, quiet);
 883   if (rc)
 884     s.set_try_server ();
 885   return rc;
 886 }
 887
 888
 889 int
 890 make_typequery(systemtap_session& s, string& module)
 891 {
 892   int rc;
 893   string new_module;
 894   vector<string> headers;
 895   bool kernel = startswith(module, "kernel");
 896
 897   for (size_t end, i = kernel ? 6 : 0; i < module.size(); i = end + 1)
 898     {
 899       if (module[i] != '<')
 900         return -1;
 901       end = module.find('>', ++i);
 902       if (end == string::npos)
 903         return -1;
 904       string header = module.substr(i, end - i);
 905       vector<string> matches;
 906       if (regexp_match(header, "^[a-zA-Z0-9/_.+-]+$", matches))
 907         s.print_warning("skipping malformed @cast header \""+ header + "\"");
 908       else
 909         headers.push_back(header);
 910     }
 911   if (headers.empty())
 912     return -1;
 913
 914   if (kernel)
 915       rc = make_typequery_kmod(s, headers, new_module);
 916   else
 917       rc = make_typequery_umod(s, headers, new_module);
 918
 919   if (!rc)
 920     module = new_module;
 921
 922   return rc;
 923 }
 924
 925 /* vim: set sw=2 ts=8 cino=>4,n-2,{2,^-2,t0,(0,u0,w1,M1 : */