[scan-build-py] intercepted executions persisted in JSON files

[rizsotto.mailinglist]

Summary

It's a chunk from D26390

Executions are intercepted by compiler wrapper or interception library. The intercepted executions are persisted in files. This file format previously was a kind of binary file.

This change:

• introduce JSON as file format,
• reduce the content of these files (don't record function name and parent PID),
• single file contains a single execution report,
• file names does not try to be ordered (using mkstemp).

[rizsotto.mailinglist]

Realized that these changes are related to environment access simplification. I hope it can be merged together.

The problem with environment access appears on OSX pre-loaded libraries. We can't access the environ variable in the pre-load phase. (Later when main is started it's not an issue anymore.) Before it was an accessor function which was called the "safe" _NSGetEnviron method or return environ on other platforms... Since exec functions are called after main started, it's safe to access the environ variable directly on OSX too.

tools/scan-build-py/libear/ear.c

42

This change is unrelated, but drifted in.

68

This change is unrelated, but drifted in.

148

This change is unrelated, but drifted in.

465

This change is unrelated, but drifted in.

521

This change is unrelated, but drifted in.

[rizsotto.mailinglist]

ping

tools/scan-build-py/libear/__init__.py

 # -*- coding: utf-8 -*-
 #                     The LLVM Compiler Infrastructure
 #
 # This file is distributed under the University of Illinois Open Source
 # License. See LICENSE.TXT for details.
 """ This module compiles the intercept library. """
 
 import sys
 import os
 import os.path
 import re
 import tempfile
 import shutil
 import contextlib
 import logging
+import subprocess
 
 __all__ = ['build_libear']
 
 
 def build_libear(compiler, dst_dir):
     """ Returns the full path to the 'libear' library. """
 
     try:
def build_libear(compiler, dst_dir):
     except Exception:
         logging.info("Could not build interception library.", exc_info=True)
         return None
 
 
 def execute(cmd, *args, **kwargs):
     """ Make subprocess execution silent. """
 
-    import subprocess
     kwargs.update({'stdout': subprocess.PIPE, 'stderr': subprocess.STDOUT})
     return subprocess.check_call(cmd, *args, **kwargs)
 
 
 @contextlib.contextmanager
 def TemporaryDirectory(**kwargs):
     name = tempfile.mkdtemp(**kwargs)
     try:

tools/scan-build-py/libear/ear.c

 
 #include <stddef.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <dlfcn.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
 #include <pthread.h>
 
 #if defined HAVE_POSIX_SPAWN || defined HAVE_POSIX_SPAWNP
 #include <spawn.h>
 #endif
 
 #if defined HAVE_NSGETENVIRON
 # include <crt_externs.h>
+static char **environ;
 #else
 extern char **environ;
 #endif
 
 #define ENV_OUTPUT "INTERCEPT_BUILD_TARGET_DIR"
 #ifdef APPLE
 # define ENV_FLAT    "DYLD_FORCE_FLAT_NAMESPACE"
 # define ENV_PRELOAD "DYLD_INSERT_LIBRARIES"
if (0 == (cast.from = dlsym(RTLD_NEXT, SYMBOL_))) {                        \
         exit(EXIT_FAILURE);                                                    \
     }                                                                          \
     TYPE_ const VAR_ = cast.to;
 
 
 typedef char const * bear_env_t[ENV_SIZE];
 
 static int bear_capture_env_t(bear_env_t *env);
-static int bear_reset_env_t(bear_env_t *env);
 static void bear_release_env_t(bear_env_t *env);
 static char const **bear_update_environment(char *const envp[], bear_env_t *env);
 static char const **bear_update_environ(char const **in, char const *key, char const *value);
-static char **bear_get_environment();
-static void bear_report_call(char const *fun, char const *const argv[]);
+static void bear_report_call(char const *const argv[]);
+static int bear_write_json_report(int fd, char const *const cmd[], char const *cwd, pid_t pid);
+static int bear_encode_json_string(char const *src, char *dst, size_t dst_size);
 static char const **bear_strings_build(char const *arg, va_list *ap);
 static char const **bear_strings_copy(char const **const in);
 static char const **bear_strings_append(char const **in, char const *e);
 static size_t bear_strings_length(char const *const *in);
 static void bear_strings_release(char const **);
 
 
 static bear_env_t env_names =

 #endif
 
 
 /* Initialization method to Captures the relevant environment variables.
  */
 
 static void on_load(void) {
     pthread_mutex_lock(&mutex);
+#ifdef HAVE_NSGETENVIRON
+    environ = *_NSGetEnviron();
+#endif
     if (!initialized)
         initialized = bear_capture_env_t(&initial_env);
     pthread_mutex_unlock(&mutex);
 }
 
 static void on_unload(void) {
     pthread_mutex_lock(&mutex);
     bear_release_env_t(&initial_env);
     initialized = 0;
     pthread_mutex_unlock(&mutex);
 }
 
 
 /* These are the methods we are try to hijack.
  */
 
 #ifdef HAVE_EXECVE
 int execve(const char *path, char *const argv[], char *const envp[]) {
-    bear_report_call(__func__, (char const *const *)argv);
+    bear_report_call((char const *const *)argv);
     return call_execve(path, argv, envp);
 }
 #endif
 
 #ifdef HAVE_EXECV
 #ifndef HAVE_EXECVE
 #error can not implement execv without execve
 #endif
 int execv(const char *path, char *const argv[]) {
-    bear_report_call(__func__, (char const *const *)argv);
-    char * const * envp = bear_get_environment();
-    return call_execve(path, argv, envp);
+    bear_report_call((char const *const *)argv);
+    return call_execve(path, argv, environ);
 }
 #endif
 
 #ifdef HAVE_EXECVPE
 int execvpe(const char *file, char *const argv[], char *const envp[]) {
-    bear_report_call(__func__, (char const *const *)argv);
+    bear_report_call((char const *const *)argv);
     return call_execvpe(file, argv, envp);
 }
 #endif
 
 #ifdef HAVE_EXECVP
 int execvp(const char *file, char *const argv[]) {
-    bear_report_call(__func__, (char const *const *)argv);
+    bear_report_call((char const *const *)argv);
     return call_execvp(file, argv);
 }
 #endif
 
 #ifdef HAVE_EXECVP2
 int execvP(const char *file, const char *search_path, char *const argv[]) {
-    bear_report_call(__func__, (char const *const *)argv);
+    bear_report_call((char const *const *)argv);
     return call_execvP(file, search_path, argv);
 }
 #endif
 
 #ifdef HAVE_EXECT
 int exect(const char *path, char *const argv[], char *const envp[]) {
-    bear_report_call(__func__, (char const *const *)argv);
+    bear_report_call((char const *const *)argv);
     return call_exect(path, argv, envp);
 }
 #endif
 
 #ifdef HAVE_EXECL
 # ifndef HAVE_EXECVE
 #  error can not implement execl without execve
 # endif
 int execl(const char *path, const char *arg, ...) {
     va_list args;
     va_start(args, arg);
     char const **argv = bear_strings_build(arg, &args);
     va_end(args);
 
-    bear_report_call(__func__, (char const *const *)argv);
-    char * const * envp = bear_get_environment();
-    int const result = call_execve(path, (char *const *)argv, envp);
+    bear_report_call((char const *const *)argv);
+    int const result = call_execve(path, (char *const *)argv, environ);
 
     bear_strings_release(argv);
     return result;
 }
 #endif
 
 #ifdef HAVE_EXECLP
 # ifndef HAVE_EXECVP
 #  error can not implement execlp without execvp
 # endif
 int execlp(const char *file, const char *arg, ...) {
     va_list args;
     va_start(args, arg);
     char const **argv = bear_strings_build(arg, &args);
     va_end(args);
 
-    bear_report_call(__func__, (char const *const *)argv);
+    bear_report_call((char const *const *)argv);
     int const result = call_execvp(file, (char *const *)argv);
 
     bear_strings_release(argv);
     return result;
 }
 #endif
 
 #ifdef HAVE_EXECLE
 # ifndef HAVE_EXECVE
 #  error can not implement execle without execve
 # endif
 // int execle(const char *path, const char *arg, ..., char * const envp[]);
 int execle(const char *path, const char *arg, ...) {
     va_list args;
     va_start(args, arg);
     char const **argv = bear_strings_build(arg, &args);
     char const **envp = va_arg(args, char const **);
     va_end(args);
 
-    bear_report_call(__func__, (char const *const *)argv);
+    bear_report_call((char const *const *)argv);
     int const result =
         call_execve(path, (char *const *)argv, (char *const *)envp);
 
     bear_strings_release(argv);
     return result;
 }
 #endif
 
 #ifdef HAVE_POSIX_SPAWN
 int posix_spawn(pid_t *restrict pid, const char *restrict path,
                 const posix_spawn_file_actions_t *file_actions,
                 const posix_spawnattr_t *restrict attrp,
                 char *const argv[restrict], char *const envp[restrict]) {
-    bear_report_call(__func__, (char const *const *)argv);
+    bear_report_call((char const *const *)argv);
     return call_posix_spawn(pid, path, file_actions, attrp, argv, envp);
 }
 #endif
 
 #ifdef HAVE_POSIX_SPAWNP
 int posix_spawnp(pid_t *restrict pid, const char *restrict file,
                  const posix_spawn_file_actions_t *file_actions,
                  const posix_spawnattr_t *restrict attrp,
                  char *const argv[restrict], char *const envp[restrict]) {
-    bear_report_call(__func__, (char const *const *)argv);
+    bear_report_call((char const *const *)argv);
     return call_posix_spawnp(pid, file, file_actions, attrp, argv, envp);
 }
 #endif
 
 /* These are the methods which forward the call to the standard implementation.
  */
 
 #ifdef HAVE_EXECVE

 #endif
 
 #ifdef HAVE_EXECVP
 static int call_execvp(const char *file, char *const argv[]) {
     typedef int (*func)(const char *file, char *const argv[]);
 
     DLSYM(func, fp, "execvp");
 
-    bear_env_t current_env;
-    bear_capture_env_t(&current_env);
-    bear_reset_env_t(&initial_env);
+    char **const original = environ;
+    char const **const modified = bear_update_environment(original, &initial_env);
+    environ = (char **)modified;
     int const result = (*fp)(file, argv);
-    bear_reset_env_t(&current_env);
-    bear_release_env_t(&current_env);
+    environ = original;
+    bear_strings_release(modified);
 
     return result;
 }
 #endif
 
 #ifdef HAVE_EXECVP2
 static int call_execvP(const char *file, const char *search_path,
                        char *const argv[]) {
     typedef int (*func)(const char *, const char *, char *const *);
 
     DLSYM(func, fp, "execvP");
 
-    bear_env_t current_env;
-    bear_capture_env_t(&current_env);
-    bear_reset_env_t(&initial_env);
+    char **const original = environ;
+    char const **const modified = bear_update_environment(original, &initial_env);
+    environ = (char **)modified;
     int const result = (*fp)(file, search_path, argv);
-    bear_reset_env_t(&current_env);
-    bear_release_env_t(&current_env);
+    environ = original;
+    bear_strings_release(modified);
 
     return result;
 }
 #endif
 
 #ifdef HAVE_EXECT
 static int call_exect(const char *path, char *const argv[],
                       char *const envp[]) {
int const result =
         (*fp)(pid, file, file_actions, attrp, argv, (char *const *restrict)menvp);
     bear_strings_release(menvp);
     return result;
 }
 #endif
 
 /* this method is to write log about the process creation. */
 
-static void bear_report_call(char const *fun, char const *const argv[]) {
-    static int const GS = 0x1d;
-    static int const RS = 0x1e;
-    static int const US = 0x1f;
-
+static void bear_report_call(char const *const argv[]) {
     if (!initialized)
         return;
 
     pthread_mutex_lock(&mutex);
     const char *cwd = getcwd(NULL, 0);
     if (0 == cwd) {
         perror("bear: getcwd");
         exit(EXIT_FAILURE);
     }
     char const * const out_dir = initial_env[0];
     size_t const path_max_length = strlen(out_dir) + 32;
     char filename[path_max_length];
-    if (-1 == snprintf(filename, path_max_length, "%s/%d.cmd", out_dir, getpid())) {
+    if (-1 == snprintf(filename, path_max_length, "%s/execution.XXXXXX", out_dir)) {
         perror("bear: snprintf");
         exit(EXIT_FAILURE);
     }
-    FILE * fd = fopen(filename, "a+");
-    if (0 == fd) {
-        perror("bear: fopen");
-        exit(EXIT_FAILURE);
-    }
-    fprintf(fd, "%d%c", getpid(), RS);
-    fprintf(fd, "%d%c", getppid(), RS);
-    fprintf(fd, "%s%c", fun, RS);
-    fprintf(fd, "%s%c", cwd, RS);
-    size_t const argc = bear_strings_length(argv);
-    for (size_t it = 0; it < argc; ++it) {
-        fprintf(fd, "%s%c", argv[it], US);
-    }
-    fprintf(fd, "%c", GS);
-    if (fclose(fd)) {
-        perror("bear: fclose");
+    int fd = mkstemp((char *)&filename);
+    if (-1 == fd) {
+        perror("bear: mkstemp");
+        exit(EXIT_FAILURE);
+    }
+    if (0 > bear_write_json_report(fd, argv, cwd, getpid())) {
+        perror("bear: writing json problem");
+        exit(EXIT_FAILURE);
+    }
+    if (close(fd)) {
+        perror("bear: close");
         exit(EXIT_FAILURE);
     }
     free((void *)cwd);
     pthread_mutex_unlock(&mutex);
 }
 
+static int bear_write_json_report(int fd, char const *const cmd[], char const *const cwd, pid_t pid) {
+    if (0 > dprintf(fd, "{ \"pid\": %d, \"cmd\": [", pid))
+        return -1;
+
+    for (char const *const *it = cmd; (it) && (*it); ++it) {
+        char const *const sep = (it != cmd) ? "," : "";
+        const size_t buffer_size = 2 * strlen(*it);
+        char buffer[buffer_size];
+        if (-1 == bear_encode_json_string(*it, buffer, buffer_size))
+            return -1;
+        if (0 > dprintf(fd, "%s \"%s\"", sep, buffer))
+            return -1;
+    }
+    const size_t buffer_size = 2 * strlen(cwd);
+    char buffer[buffer_size];
+    if (-1 == bear_encode_json_string(cwd, buffer, buffer_size))
+        return -1;
+    if (0 > dprintf(fd, "], \"cwd\": \"%s\" }", buffer))
+        return -1;
+
+    return 0;
+}
+
+static int bear_encode_json_string(char const *const src, char *const dst, size_t const dst_size) {
+    char const *src_it = src;
+    char const *const src_end = src + strlen(src);
+
+    char *dst_it = dst;
+    char *const dst_end = dst + dst_size;
+
+    for (; src_it != src_end; ++src_it, ++dst_it) {
+        if (dst_it == dst_end)
+            return -1;
+        // Insert an escape character before control characters.
+        switch (*src_it) {
+        case '\b':
+        case '\f':
+        case '\n':
+        case '\r':
+        case '\t':
+        case '"':
+        case '\\':
+            *dst_it++ = '\\';
+            break;
+        default:
+            break;
+        }
+        // Transform some of the control characters.
+        switch (*src_it) {
+        case '\b':
+            *dst_it = 'b';
+            break;
+        case '\f':
+            *dst_it = 'f';
+            break;
+        case '\n':
+            *dst_it = 'n';
+            break;
+        case '\r':
+            *dst_it = 'r';
+            break;
+        case '\t':
+            *dst_it = 't';
+            break;
+        default:
+            *dst_it = *src_it;
+        }
+    }
+    if (dst_it == dst_end)
+        return -1;
+    // Insert a terminating 0 value.
+    *dst_it = 0;
+    return 0;
+}
+
 /* update environment assure that chilren processes will copy the desired
  * behaviour */
 
 static int bear_capture_env_t(bear_env_t *env) {
     int status = 1;
     for (size_t it = 0; it < ENV_SIZE; ++it) {
         char const * const env_value = getenv(env_names[it]);
         char const * const env_copy = (env_value) ? strdup(env_value) : env_value;
         (*env)[it] = env_copy;
         status &= (env_copy) ? 1 : 0;
     }
     return status;
 }
 
-static int bear_reset_env_t(bear_env_t *env) {
-    int status = 1;
-    for (size_t it = 0; it < ENV_SIZE; ++it) {
-        if ((*env)[it]) {
-            setenv(env_names[it], (*env)[it], 1);
-        } else {
-            unsetenv(env_names[it]);
-        }
-    }
-    return status;
-}
-
 static void bear_release_env_t(bear_env_t *env) {
     for (size_t it = 0; it < ENV_SIZE; ++it) {
         free((void *)(*env)[it]);
         (*env)[it] = 0;
     }
 }
 
 static char const **bear_update_environment(char *const envp[], bear_env_t *env) {
static char const **bear_update_environ(char const *envs[], char const *key, char const * const value) {
     if (it && *it) {
         free((void *)*it);
         *it = env;
   return envs;
     }
     return bear_strings_append(envs, env);
 }
 
-static char **bear_get_environment() {
-#if defined HAVE_NSGETENVIRON
-    return *_NSGetEnviron();
-#else
-    return environ;
-#endif
-}
-
 /* util methods to deal with string arrays. environment and process arguments
  * are both represented as string arrays. */
 
 static char const **bear_strings_build(char const *const arg, va_list *args) {
     char const **result = 0;
     size_t size = 0;
     for (char const *it = arg; it; it = va_arg(*args, char const *)) {
         result = realloc(result, (size + 1) * sizeof(char const *));

tools/scan-build-py/libscanbuild/intercept.py

 the output files, which will condensates into a compilation database. """
 
 import sys
 import os
 import os.path
 import re
 import itertools
 import json
-import glob
 import logging
+import uuid
 from libear import build_libear, TemporaryDirectory
 from libscanbuild import command_entry_point, compiler_wrapper, \
-    wrapper_environment, run_command, run_build
+    wrapper_environment, run_command, run_build, Execution
 from libscanbuild import duplicate_check
 from libscanbuild.compilation import split_command
 from libscanbuild.arguments import parse_args_for_intercept_build
 from libscanbuild.shell import encode, decode
 
 __all__ = ['capture', 'intercept_build', 'intercept_compiler_wrapper']
 
-GS = chr(0x1d)
-RS = chr(0x1e)
-US = chr(0x1f)
-
 COMPILER_WRAPPER_CC = 'intercept-cc'
 COMPILER_WRAPPER_CXX = 'intercept-c++'
-TRACE_FILE_EXTENSION = '.cmd'  # same as in ear.c
+TRACE_FILE_PREFIX = 'execution.'  # same as in ear.c
 WRAPPER_ONLY_PLATFORMS = frozenset({'win32', 'cygwin'})
 
 
 @command_entry_point
 def intercept_build():
     """ Entry point for 'intercept-build' command. """
 
     args = parse_args_for_intercept_build()
def post_processing(commands):
                 for entry in itertools.chain(previous, current)
                 if os.path.exists(entry['file']) and not duplicate(entry))
 
     with TemporaryDirectory(prefix='intercept-') as tmp_dir:
         # run the build command
         environment = setup_environment(args, tmp_dir)
         exit_code = run_build(args.build, env=environment)
         # read the intercepted exec calls
-        exec_traces = itertools.chain.from_iterable(
-            parse_exec_trace(os.path.join(tmp_dir, filename))
-            for filename in sorted(glob.iglob(os.path.join(tmp_dir, '*.cmd'))))
+        calls = (parse_exec_trace(file) for file in exec_trace_files(tmp_dir))
         # do post processing
-        entries = post_processing(exec_traces)
+        entries = post_processing(calls)
         # dump the compilation database
         with open(args.cdb, 'w+') as handle:
             json.dump(list(entries), handle, sort_keys=True, indent=4)
         return exit_code
 
 
 def setup_environment(args, destination):
     """ Sets up the environment for the build command.
def intercept_compiler_wrapper_impl(_, execution):
     message_prefix = 'execution report might be incomplete: %s'
 
     target_dir = os.getenv('INTERCEPT_BUILD_TARGET_DIR')
     if not target_dir:
         logging.warning(message_prefix, 'missing target directory')
         return
     # write current execution info to the pid file
     try:
-        target_file_name = str(os.getpid()) + TRACE_FILE_EXTENSION
+        target_file_name = TRACE_FILE_PREFIX + str(uuid.uuid4())
         target_file = os.path.join(target_dir, target_file_name)
         logging.debug('writing execution report to: %s', target_file)
         write_exec_trace(target_file, execution)
     except IOError:
         logging.warning(message_prefix, 'io problem')
 
 
 def write_exec_trace(filename, entry):
     """ Write execution report file.
 
     This method shall be sync with the execution report writer in interception
     library. The entry in the file is a JSON objects.
 
     :param filename:    path to the output execution trace file,
     :param entry:       the Execution object to append to that file. """
 
-    with open(filename, 'ab') as handler:
-        pid = str(entry.pid)
-        command = US.join(entry.cmd) + US
-        content = RS.join([pid, pid, 'wrapper', entry.cwd, command]) + GS
-        handler.write(content.encode('utf-8'))
+    call = {'pid': entry.pid, 'cwd': entry.cwd, 'cmd': entry.cmd}
+    with open(filename, 'w') as handler:
+        json.dump(call, handler)
 
 
 def parse_exec_trace(filename):
-    """ Parse the file generated by the 'libear' preloaded library.
+    """ Parse execution report file.
 
     Given filename points to a file which contains the basic report
-    generated by the interception library or wrapper command. A single
-    report file _might_ contain multiple process creation info. """
+    generated by the interception library or compiler wrapper.
+
+    :param filename: path to an execution trace file to read from,
+    :return: an Execution object. """
 
     logging.debug('parse exec trace file: %s', filename)
     with open(filename, 'r') as handler:
-        content = handler.read()
-        for group in filter(bool, content.split(GS)):
-            records = group.split(RS)
-            yield {
-                'pid': records[0],
-                'ppid': records[1],
-                'function': records[2],
-                'directory': records[3],
-                'command': records[4].split(US)[:-1]
-            }
+        entry = json.load(handler)
+        return Execution(
+            pid=entry['pid'],
+            cwd=entry['cwd'],
+            cmd=entry['cmd'])
+
+
+def exec_trace_files(directory):
+    """ Generates exec trace file names.
+
+    :param directory:   path to directory which contains the trace files.
+    :return:            a generator of file names (absolute path). """
+
+    for root, _, files in os.walk(directory):
+        for candidate in files:
+            if candidate.startswith(TRACE_FILE_PREFIX):
+                yield os.path.join(root, candidate)
 
 
-def format_entry(exec_trace):
+def format_entry(execution):
     """ Generate the desired fields for compilation database entries. """
 
     def abspath(cwd, name):
         """ Create normalized absolute path from input filename. """
         fullname = name if os.path.isabs(name) else os.path.join(cwd, name)
         return os.path.normpath(fullname)
 
-    logging.debug('format this command: %s', exec_trace['command'])
-    compilation = split_command(exec_trace['command'])
+    logging.debug('format this command: %s', execution.cmd)
+    compilation = split_command(execution.cmd)
     if compilation:
         for source in compilation.files:
             compiler = 'c++' if compilation.compiler == 'c++' else 'cc'
             command = [compiler, '-c'] + compilation.flags + [source]
             logging.debug('formated as: %s', command)
             yield {
-                'directory': exec_trace['directory'],
+                'directory': execution.cwd,
                 'command': encode(command),
-                'file': abspath(exec_trace['directory'], source)
+                'file': abspath(execution.cwd, source)
             }
 
 
 def is_preload_disabled(platform):
     """ Library-based interposition will fail silently if SIP is enabled,
     so this should be detected. You can detect whether SIP is enabled on
     Darwin by checking whether (1) there is a binary called 'csrutil' in
     the path and, if so, (2) whether the output of executing 'csrutil status'

tools/scan-build-py/tests/unit/test_intercept.py

 # -*- coding: utf-8 -*-
 #                     The LLVM Compiler Infrastructure
 #
 # This file is distributed under the University of Illinois Open Source
 # License. See LICENSE.TXT for details.
 
 import libear
 import libscanbuild.intercept as sut
+from libscanbuild import Execution
 import unittest
 import os.path
 
 
 class InterceptUtilTest(unittest.TestCase):
 
     def test_format_entry_filters_action(self):
         def test(command):
-            trace = {'command': command, 'directory': '/opt/src/project'}
+            trace = Execution(cmd=command, cwd='/opt/src/project', pid=0)
             return list(sut.format_entry(trace))
 
         self.assertTrue(test(['cc', '-c', 'file.c', '-o', 'file.o']))
         self.assertFalse(test(['cc', '-E', 'file.c']))
         self.assertFalse(test(['cc', '-MM', 'file.c']))
         self.assertFalse(test(['cc', 'this.o', 'that.o', '-o', 'a.out']))
 
     def test_format_entry_normalize_filename(self):
         parent = os.path.join(os.sep, 'home', 'me')
         current = os.path.join(parent, 'project')
 
         def test(filename):
-            trace = {'directory': current, 'command': ['cc', '-c', filename]}
+            trace = Execution(cmd=['cc', '-c', filename], cwd=current, pid=0)
             return list(sut.format_entry(trace))[0]['file']
 
         self.assertEqual(os.path.join(current, 'file.c'), test('file.c'))
         self.assertEqual(os.path.join(current, 'file.c'), test('./file.c'))
         self.assertEqual(os.path.join(parent, 'file.c'), test('../file.c'))
         self.assertEqual(os.path.join(current, 'file.c'),
                          test(os.path.join(current, 'file.c')))