X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fjournal%2Fjournal-vacuum.c;h=d4a1c6c9334ff736bbe3066e7d0b317c71119b7b;hp=c89014653784d88e5634dc27a6d07ec8966ef7a8;hb=e5462cd80e5328a769137c261c93931ea0c27bab;hpb=2b43f939a4b3ad5aeb2650868b0234ff42ec0045 diff --git a/src/journal/journal-vacuum.c b/src/journal/journal-vacuum.c index c89014653..d4a1c6c93 100644 --- a/src/journal/journal-vacuum.c +++ b/src/journal/journal-vacuum.c @@ -25,6 +25,10 @@ #include #include +#ifdef HAVE_XATTR +#include +#endif + #include "journal-def.h" #include "journal-file.h" #include "journal-vacuum.h" @@ -32,7 +36,7 @@ #include "util.h" struct vacuum_info { - off_t usage; + uint64_t usage; char *filename; uint64_t realtime; @@ -68,25 +72,117 @@ static int vacuum_compare(const void *_a, const void *_b) { return strcmp(a->filename, b->filename); } -int journal_directory_vacuum(const char *directory, uint64_t max_use, uint64_t min_free) { - DIR *d; +static void patch_realtime( + const char *dir, + const char *fn, + const struct stat *st, + unsigned long long *realtime) { + + usec_t x; + +#ifdef HAVE_XATTR + uint64_t crtime; + _cleanup_free_ const char *path = NULL; +#endif + + /* The timestamp was determined by the file name, but let's + * see if the file might actually be older than the file name + * suggested... */ + + assert(dir); + assert(fn); + assert(st); + assert(realtime); + + x = timespec_load(&st->st_ctim); + if (x > 0 && x != (usec_t) -1 && x < *realtime) + *realtime = x; + + x = timespec_load(&st->st_atim); + if (x > 0 && x != (usec_t) -1 && x < *realtime) + *realtime = x; + + x = timespec_load(&st->st_mtim); + if (x > 0 && x != (usec_t) -1 && x < *realtime) + *realtime = x; + +#ifdef HAVE_XATTR + /* Let's read the original creation time, if possible. Ideally + * we'd just query the creation time the FS might provide, but + * unfortunately there's currently no sane API to query + * it. Hence let's implement this manually... */ + + /* Unfortunately there is is not fgetxattrat(), so we need to + * go via path here. :-( */ + + path = strjoin(dir, "/", fn, NULL); + if (!path) + return; + + if (getxattr(path, "user.crtime_usec", &crtime, sizeof(crtime)) == sizeof(crtime)) { + crtime = le64toh(crtime); + + if (crtime > 0 && crtime != (uint64_t) -1 && crtime < *realtime) + *realtime = crtime; + } +#endif +} + +static int journal_file_empty(int dir_fd, const char *name) { + int r; + le64_t n_entries; + _cleanup_close_ int fd; + + fd = openat(dir_fd, name, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK); + if (fd < 0) + return -errno; + + if (lseek(fd, offsetof(Header, n_entries), SEEK_SET) < 0) + return -errno; + + r = read(fd, &n_entries, sizeof(n_entries)); + if (r != sizeof(n_entries)) + return r == 0 ? -EINVAL : -errno; + + return le64toh(n_entries) == 0; +} + +int journal_directory_vacuum( + const char *directory, + uint64_t max_use, + uint64_t min_free, + usec_t max_retention_usec, + usec_t *oldest_usec) { + + _cleanup_closedir_ DIR *d = NULL; int r = 0; struct vacuum_info *list = NULL; - unsigned n_list = 0, n_allocated = 0, i; - uint64_t sum = 0; + unsigned n_list = 0, i; + size_t n_allocated = 0; + uint64_t sum = 0, freed = 0; + usec_t retention_limit = 0; assert(directory); - if (max_use <= 0) + if (max_use <= 0 && min_free <= 0 && max_retention_usec <= 0) return 0; + if (max_retention_usec > 0) { + retention_limit = now(CLOCK_REALTIME); + if (retention_limit > max_retention_usec) + retention_limit -= max_retention_usec; + else + max_retention_usec = retention_limit = 0; + } + d = opendir(directory); if (!d) return -errno; for (;;) { int k; - struct dirent buf, *de; + struct dirent *de; + union dirent_storage buf; size_t q; struct stat st; char *p; @@ -94,7 +190,7 @@ int journal_directory_vacuum(const char *directory, uint64_t max_use, uint64_t m sd_id128_t seqnum_id; bool have_seqnum; - k = readdir_r(d, &buf, &de); + k = readdir_r(d, &buf.de, &de); if (k != 0) { r = -k; goto finish; @@ -167,22 +263,30 @@ int journal_directory_vacuum(const char *directory, uint64_t max_use, uint64_t m have_seqnum = false; } else + /* We do not vacuum active files or unknown files! */ continue; - if (n_list >= n_allocated) { - struct vacuum_info *j; + if (journal_file_empty(dirfd(d), p)) { + /* Always vacuum empty non-online files. */ - n_allocated = MAX(n_allocated * 2U, 8U); - j = realloc(list, n_allocated * sizeof(struct vacuum_info)); - if (!j) { - free(p); - r = -ENOMEM; - goto finish; - } + uint64_t size = 512UL * (uint64_t) st.st_blocks; + + if (unlinkat(dirfd(d), p, 0) >= 0) { + log_info("Deleted empty journal %s/%s (%"PRIu64" bytes).", + directory, p, size); + freed += size; + } else if (errno != ENOENT) + log_warning("Failed to delete %s/%s: %m", directory, p); + + free(p); - list = j; + continue; } + patch_realtime(directory, p, &st, &realtime); + + GREEDY_REALLOC(list, n_allocated, n_list + 1); + list[n_list].filename = p; list[n_list].usage = 512UL * (uint64_t) st.st_blocks; list[n_list].seqnum = seqnum; @@ -195,10 +299,9 @@ int journal_directory_vacuum(const char *directory, uint64_t max_use, uint64_t m n_list ++; } - if (n_list > 0) - qsort(list, n_list, sizeof(struct vacuum_info), vacuum_compare); + qsort_safe(list, n_list, sizeof(struct vacuum_info), vacuum_compare); - for(i = 0; i < n_list; i++) { + for (i = 0; i < n_list; i++) { struct statvfs ss; if (fstatvfs(dirfd(d), &ss) < 0) { @@ -206,25 +309,34 @@ int journal_directory_vacuum(const char *directory, uint64_t max_use, uint64_t m goto finish; } - if (sum <= max_use && - (uint64_t) ss.f_bavail * (uint64_t) ss.f_bsize >= min_free) + if ((max_retention_usec <= 0 || list[i].realtime >= retention_limit) && + (max_use <= 0 || sum <= max_use) && + (min_free <= 0 || (uint64_t) ss.f_bavail * (uint64_t) ss.f_bsize >= min_free)) break; if (unlinkat(dirfd(d), list[i].filename, 0) >= 0) { - log_debug("Deleted archived journal %s/%s.", directory, list[i].filename); - sum -= list[i].usage; + log_debug("Deleted archived journal %s/%s (%"PRIu64" bytes).", + directory, list[i].filename, list[i].usage); + freed += list[i].usage; + + if (list[i].usage < sum) + sum -= list[i].usage; + else + sum = 0; + } else if (errno != ENOENT) log_warning("Failed to delete %s/%s: %m", directory, list[i].filename); } + if (oldest_usec && i < n_list && (*oldest_usec == 0 || list[i].realtime < *oldest_usec)) + *oldest_usec = list[i].realtime; + finish: for (i = 0; i < n_list; i++) free(list[i].filename); - free(list); - if (d) - closedir(d); + log_info("Vacuuming done, freed %"PRIu64" bytes", freed); return r; }