/* Create the directory that will be needed for the cache file for \key.
*
* Obviously, the implementation here must closely match
* _get_cache_file above.
*/
static void
make_cache_file_directory(struct program_cache *cache, cache_key key)
{
char *dir;
char buf[41];
_mesa_sha1_format(buf, key);
dir = ralloc_asprintf(cache, "%s/%c%c", cache->path, buf[0], buf[1]);
mkdir_if_needed(dir);
ralloc_free(dir);
}
/* Concatenate an existing path and a new name to form a new path. If the new
* path does not exist as a directory, create it then return the resulting
* name of the new path (ralloc'ed off of 'ctx').
*
* Returns NULL on any error, such as:
*
* <path> does not exist or is not a directory
* <path>/<name> exists but is not a directory
* <path>/<name> cannot be created as a directory
*/
static char *
concatenate_and_mkdir(void *ctx, char *path, char *name)
{
char *new_path;
struct stat sb;
if (stat(path, &sb) != 0 || ! S_ISDIR(sb.st_mode))
return NULL;
new_path = ralloc_asprintf(ctx, "%s/%s", path, name);
if (mkdir_if_needed(new_path) == 0)
return new_path;
else
return NULL;
}
/* routine via which the dot file is written */
void write_dot(const char * prefix, int id, const char *fmt, ...)
{
static int flag = 0;
static FILE * dotf[MAX_DOTF_NR];
static char dotfilename[MAX_DOTF_NR][FILENAME_MAX];
char cmd[CMD_MAX];
char * fig_folder = "fig";
va_list args;
va_start(args, fmt);
assert(id >= 0 && id < MAX_DOTF_NR);
if (id < LOWEST_DOT_ID)
return;
if (!flag) {
int i;
for (i = 0; i < MAX_DOTF_NR; i++)
dotf[i] = 0;
flag = 1;
}
if (!dotf[id]) {
sprintf(dotfilename[id], "%s/%s (%03d).%s",
fig_folder, prefix, id, GRAPHVIZ_FILE_EXT);
if (flag == 1) {
flag = 2;
mkdir_if_needed(dotfilename[id]);
}
fprintf(stderr, "%sdot file: %s%s\n", INFO_COLOR,
dotfilename[id], NOCOLOR);
dotf[id] = fopen(dotfilename[id], "w");
if (dotf[id] == 0)
F_ERR(dotf[id], "failed to open file ``%s%s%s''",
ERR_EMPH_COLOR, dotfilename[id], ERR_COLOR);
fprintf(dotf[id], "graph sort {\n");
fprintf(dotf[id],
"\tnode [shape=circle"
", fontname=Courier New"
", penwidth=0.5"
", fixedsize=true"
", width=0.6"
/* ", height=0.7" */
", splines=\"compound\""
"];\n");
}
assert(dotf[id] != 0);
/* if the dot file becomes big, something must be wrong */
int dot_f_max_size = 32*1024;
if (ftell(dotf[id]) > dot_f_max_size) {
fprintf(stderr,
"%sdot file too big: %s"
"%s%s%s"
"%s, something must be wrong.\n%s",
YELLOW, NOCOLOR,
RED, dotfilename[id], NOCOLOR,
YELLOW, NOCOLOR);
assert(ftell(dotf[id]) <= dot_f_max_size);
}
if (!fmt[0]) {
fprintf(dotf[id], "}\n");
fclose(dotf[id]);
dotf[id] = 0;
snprintf(cmd, (size_t)CMD_MAX, "%s -T%s \"%s\" -o "
"\"%s/%s (%03d).%s\"",
GRAPHVIZ_CMD, GRAPHVIZ_FIG_TYPE, dotfilename[id],
fig_folder, prefix, id, GRAPHVIZ_FIG_TYPE);
printf("%s$ %s%s%s\n", WHITE, WHITE, cmd, NOCOLOR);
/* printf("%s$ %s%s%s\n", WHITE, GREEN, cmd, NOCOLOR); */
assert(system(cmd) == 0);
} else {
fprintf(dotf[id], "\t");
vfprintf(dotf[id], fmt, args);
}
va_end(args);
}
struct program_cache *
cache_create(void)
{
void *local;
struct program_cache *cache = NULL;
char *path, *max_size_str;
uint64_t max_size;
int fd = -1;
struct stat sb;
size_t size;
/* A ralloc context for transient data during this invocation. */
local = ralloc_context(NULL);
if (local == NULL)
goto fail;
/* At user request, disable shader cache entirely. */
if (getenv("MESA_GLSL_CACHE_DISABLE"))
goto fail;
/* Determine path for cache based on the first defined name as follows:
*
* $MESA_GLSL_CACHE_DIR
* $XDG_CACHE_HOME/mesa
* <pwd.pw_dir>/.cache/mesa
*/
path = getenv("MESA_GLSL_CACHE_DIR");
if (path && mkdir_if_needed(path) == -1) {
goto fail;
}
if (path == NULL) {
char *xdg_cache_home = getenv("XDG_CACHE_HOME");
if (xdg_cache_home) {
if (mkdir_if_needed(xdg_cache_home) == -1)
goto fail;
path = concatenate_and_mkdir(local, xdg_cache_home, "mesa");
if (path == NULL)
goto fail;
}
}
if (path == NULL) {
char *buf;
size_t buf_size;
struct passwd pwd, *result;
buf_size = sysconf(_SC_GETPW_R_SIZE_MAX);
if (buf_size == -1)
buf_size = 512;
/* Loop until buf_size is large enough to query the directory */
while (1) {
buf = ralloc_size(local, buf_size);
getpwuid_r(getuid(), &pwd, buf, buf_size, &result);
if (result)
break;
if (errno == ERANGE) {
ralloc_free(buf);
buf = NULL;
buf_size *= 2;
} else {
goto fail;
}
}
path = concatenate_and_mkdir(local, pwd.pw_dir, ".cache");
if (path == NULL)
goto fail;
path = concatenate_and_mkdir(local, path, "mesa");
if (path == NULL)
goto fail;
}
cache = ralloc(NULL, struct program_cache);
if (cache == NULL)
goto fail;
cache->path = ralloc_strdup(cache, path);
if (cache->path == NULL)
goto fail;
path = ralloc_asprintf(local, "%s/index", cache->path);
if (path == NULL)
goto fail;
fd = open(path, O_RDWR | O_CREAT | O_CLOEXEC, 0644);
if (fd == -1)
goto fail;
if (fstat(fd, &sb) == -1)
goto fail;
/* Force the index file to be the expected size. */
size = sizeof(*cache->size) + CACHE_INDEX_MAX_KEYS * CACHE_KEY_SIZE;
if (sb.st_size != size) {
if (ftruncate(fd, size) == -1)
goto fail;
}
/* We map this shared so that other processes see updates that we
* make.
*
* Note: We do use atomic addition to ensure that multiple
* processes don't scramble the cache size recorded in the
* index. But we don't use any locking to prevent multiple
* processes from updating the same entry simultaneously. The idea
* is that if either result lands entirely in the index, then
* that's equivalent to a well-ordered write followed by an
* eviction and a write. On the other hand, if the simultaneous
* writes result in a corrupt entry, that's not really any
* different than both entries being evicted, (since within the
* guarantees of the cryptographic hash, a corrupt entry is
* unlikely to ever match a real cache key).
*/
cache->index_mmap = mmap(NULL, size, PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0);
if (cache->index_mmap == MAP_FAILED)
goto fail;
cache->index_mmap_size = size;
close(fd);
cache->size = (uint64_t *) cache->index_mmap;
cache->stored_keys = cache->index_mmap + sizeof(uint64_t);
max_size = 0;
max_size_str = getenv("MESA_GLSL_CACHE_MAX_SIZE");
if (max_size_str) {
char *end;
max_size = strtoul(max_size_str, &end, 10);
if (end == max_size_str) {
max_size = 0;
} else {
while (*end && isspace(*end))
end++;
switch (*end) {
case 'K':
case 'k':
max_size *= 1024;
break;
case 'M':
case 'm':
max_size *= 1024*1024;
break;
case '\0':
case 'G':
case 'g':
default:
max_size *= 1024*1024*1024;
break;
}
}
}
/* Default to 1GB for maximum cache size. */
if (max_size == 0)
max_size = 1024*1024*1024;
cache->max_size = max_size;
ralloc_free(local);
return cache;
fail:
if (fd != -1)
close(fd);
if (cache)
ralloc_free(cache);
ralloc_free(local);
return NULL;
}