// Put the object name into a manifest file given a set of included files.
// Returns true on success, otherwise false.
bool
manifest_put(const char *manifest_path, struct file_hash *object_hash,
struct hashtable *included_files)
{
int ret = 0;
gzFile f2 = NULL;
struct manifest *mf = NULL;
char *tmp_file = NULL;
// We don't bother to acquire a lock when writing the manifest to disk. A
// race between two processes will only result in one lost entry, which is
// not a big deal, and it's also very unlikely.
int fd1 = open(manifest_path, O_RDONLY | O_BINARY);
if (fd1 == -1) {
// New file.
mf = create_empty_manifest();
} else {
gzFile f1 = gzdopen(fd1, "rb");
if (!f1) {
cc_log("Failed to gzdopen manifest file");
close(fd1);
goto out;
}
mf = read_manifest(f1);
gzclose(f1);
if (!mf) {
cc_log("Failed to read manifest file; deleting it");
x_unlink(manifest_path);
mf = create_empty_manifest();
}
}
if (mf->n_objects > MAX_MANIFEST_ENTRIES) {
// Normally, there shouldn't be many object entries in the manifest since
// new entries are added only if an include file has changed but not the
// source file, and you typically change source files more often than
// header files. However, it's certainly possible to imagine cases where
// the manifest will grow large (for instance, a generated header file that
// changes for every build), and this must be taken care of since
// processing an ever growing manifest eventually will take too much time.
// A good way of solving this would be to maintain the object entries in
// LRU order and discarding the old ones. An easy way is to throw away all
// entries when there are too many. Let's do that for now.
cc_log("More than %u entries in manifest file; discarding",
MAX_MANIFEST_ENTRIES);
free_manifest(mf);
mf = create_empty_manifest();
} else if (mf->n_file_infos > MAX_MANIFEST_FILE_INFO_ENTRIES) {
// Rarely, file_info entries can grow large in pathological cases where
// many included files change, but the main file does not. This also puts
// an upper bound on the number of file_info entries.
cc_log("More than %u file_info entries in manifest file; discarding",
MAX_MANIFEST_FILE_INFO_ENTRIES);
free_manifest(mf);
mf = create_empty_manifest();
}
tmp_file = format("%s.tmp", manifest_path);
int fd2 = create_tmp_fd(&tmp_file);
f2 = gzdopen(fd2, "wb");
if (!f2) {
cc_log("Failed to gzdopen %s", tmp_file);
goto out;
}
add_object_entry(mf, object_hash, included_files);
if (write_manifest(f2, mf)) {
gzclose(f2);
f2 = NULL;
if (x_rename(tmp_file, manifest_path) == 0) {
ret = 1;
} else {
cc_log("Failed to rename %s to %s", tmp_file, manifest_path);
goto out;
}
} else {
cc_log("Failed to write manifest file");
goto out;
}
out:
if (mf) {
free_manifest(mf);
}
if (tmp_file) {
free(tmp_file);
}
if (f2) {
gzclose(f2);
}
return ret;
}
/*
* Put the object name into a manifest file given a set of included files.
* Returns true on success, otherwise false.
*/
bool
manifest_put(const char *manifest_path, struct file_hash *object_hash,
struct hashtable *included_files)
{
int ret = 0;
int fd1;
int fd2;
gzFile f2 = NULL;
struct manifest *mf = NULL;
char *tmp_file = NULL;
/*
* We don't bother to acquire a lock when writing the manifest to disk. A
* race between two processes will only result in one lost entry, which is
* not a big deal, and it's also very unlikely.
*/
fd1 = open(manifest_path, O_RDONLY | O_BINARY);
if (fd1 == -1) {
/* New file. */
mf = create_empty_manifest();
} else {
gzFile f1 = gzdopen(fd1, "rb");
if (!f1) {
cc_log("Failed to gzdopen manifest file");
close(fd1);
goto out;
}
mf = read_manifest(f1);
gzclose(f1);
if (!mf) {
cc_log("Failed to read manifest file; deleting it");
x_unlink(manifest_path);
mf = create_empty_manifest();
}
}
if (mf->n_objects > MAX_MANIFEST_ENTRIES) {
/*
* Normally, there shouldn't be many object entries in the manifest since
* new entries are added only if an include file has changed but not the
* source file, and you typically change source files more often than
* header files. However, it's certainly possible to imagine cases where
* the manifest will grow large (for instance, a generated header file that
* changes for every build), and this must be taken care of since
* processing an ever growing manifest eventually will take too much time.
* A good way of solving this would be to maintain the object entries in
* LRU order and discarding the old ones. An easy way is to throw away all
* entries when there are too many. Let's do that for now.
*/
cc_log("More than %u entries in manifest file; discarding",
MAX_MANIFEST_ENTRIES);
free_manifest(mf);
mf = create_empty_manifest();
}
tmp_file = format("%s.tmp.%s", manifest_path, tmp_string());
fd2 = safe_create_wronly(tmp_file);
if (fd2 == -1) {
cc_log("Failed to open %s", tmp_file);
goto out;
}
f2 = gzdopen(fd2, "wb");
if (!f2) {
cc_log("Failed to gzdopen %s", tmp_file);
goto out;
}
add_object_entry(mf, object_hash, included_files);
if (write_manifest(f2, mf)) {
gzclose(f2);
f2 = NULL;
if (x_rename(tmp_file, manifest_path) == 0) {
ret = 1;
} else {
cc_log("Failed to rename %s to %s", tmp_file, manifest_path);
goto out;
}
} else {
cc_log("Failed to write manifest file");
goto out;
}
out:
if (mf) {
free_manifest(mf);
}
if (tmp_file) {
free(tmp_file);
}
if (f2) {
gzclose(f2);
}
return ret;
}