#include "cache.h" #include "config.h" #include "dir.h" #include "ewah/ewok.h" #include "fsmonitor.h" #include "run-command.h" #include "strbuf.h" #define INDEX_EXTENSION_VERSION (1) #define HOOK_INTERFACE_VERSION (1) struct trace_key trace_fsmonitor = TRACE_KEY_INIT(FSMONITOR); static void fsmonitor_ewah_callback(size_t pos, void *is) { struct index_state *istate = (struct index_state *)is; struct cache_entry *ce = istate->cache[pos]; ce->ce_flags &= ~CE_FSMONITOR_VALID; } int read_fsmonitor_extension(struct index_state *istate, const void *data, unsigned long sz) { const char *index = data; uint32_t hdr_version; uint32_t ewah_size; struct ewah_bitmap *fsmonitor_dirty; int ret; if (sz < sizeof(uint32_t) + sizeof(uint64_t) + sizeof(uint32_t))
#include "cache.h" #include "wt-status.h" #include "pkt-line.h" static struct trace_key trace_serialize = TRACE_KEY_INIT(SERIALIZE); /* * Write V1 header fields. */ static void wt_serialize_v1_header(struct wt_status *s, int fd) { /* * Write select fields from the current index to help * the deserializer recognize a stale data set. */ packet_write_fmt(fd, "index_mtime %d %d\n", the_index.timestamp.sec, the_index.timestamp.nsec); /* * Write data from wt_status to qualify this status report. * That is, if this run specified "-uno", the consumer of * our serialization should know that. */ packet_write_fmt(fd, "is_initial %d\n", s->is_initial); if (s->branch) packet_write_fmt(fd, "branch %s\n", s->branch); if (s->reference) packet_write_fmt(fd, "reference %s\n", s->reference); /* pathspec */ /* verbose */
#include "cache.h" #include "pkt-line.h" #include "run-command.h" char packet_buffer[LARGE_PACKET_MAX]; static const char *packet_trace_prefix = "git"; static struct trace_key trace_packet = TRACE_KEY_INIT(PACKET); static struct trace_key trace_pack = TRACE_KEY_INIT(PACKFILE); void packet_trace_identity(const char *prog) { packet_trace_prefix = xstrdup(prog); } static const char *get_trace_prefix(void) { return in_async() ? "sideband" : packet_trace_prefix; } static int packet_trace_pack(const char *buf, unsigned int len, int sideband) { if (!sideband) { trace_verbatim(&trace_pack, buf, len); return 1; } else if (len && *buf == '\1') { trace_verbatim(&trace_pack, buf + 1, len - 1); return 1; } else { /* it's another non-pack sideband */ return 0; }
volatile long enabled; struct hashmap map; struct mem_pool *mem_pool; unsigned int lstat_requests; unsigned int opendir_requests; unsigned int fscache_requests; unsigned int fscache_misses; /* * 32k wide characters translates to 64kB, which is the maximum that * Windows 8.1 and earlier can handle. On network drives, not only * the client's Windows version matters, but also the server's, * therefore we need to keep this to 64kB. */ WCHAR buffer[32 * 1024]; }; static struct trace_key trace_fscache = TRACE_KEY_INIT(FSCACHE); /* * An entry in the file system cache. Used for both entire directory listings * and file entries. */ struct fsentry { struct hashmap_entry ent; mode_t st_mode; /* Length of name. */ unsigned short len; /* * Name of the entry. For directory listings: relative path of the * directory, without trailing '/' (empty for cwd()). For file entries: * name of the file. Typically points to the end of the structure if * the fsentry is allocated on the heap (see fsentry_alloc), or to a