src/journal/coredump-vacuum.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2014 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <sys/statvfs.h>
  23
  24 #include "alloc-util.h"
  25 #include "coredump-vacuum.h"
  26 #include "dirent-util.h"
  27 #include "fd-util.h"
  28 #include "hashmap.h"
  29 #include "macro.h"
  30 #include "string-util.h"
  31 #include "time-util.h"
  32 #include "user-util.h"
  33 #include "util.h"
  34
  35 #define DEFAULT_MAX_USE_LOWER (uint64_t) (1ULL*1024ULL*1024ULL)           /* 1 MiB */
  36 #define DEFAULT_MAX_USE_UPPER (uint64_t) (4ULL*1024ULL*1024ULL*1024ULL)   /* 4 GiB */
  37 #define DEFAULT_KEEP_FREE_UPPER (uint64_t) (4ULL*1024ULL*1024ULL*1024ULL) /* 4 GiB */
  38 #define DEFAULT_KEEP_FREE (uint64_t) (1024ULL*1024ULL)                    /* 1 MB */
  39
  40 struct vacuum_candidate {
  41         unsigned n_files;
  42         char *oldest_file;
  43         usec_t oldest_mtime;
  44 };
  45
  46 static void vacuum_candidate_free(struct vacuum_candidate *c) {
  47         if (!c)
  48                 return;
  49
  50         free(c->oldest_file);
  51         free(c);
  52 }
  53
  54 DEFINE_TRIVIAL_CLEANUP_FUNC(struct vacuum_candidate*, vacuum_candidate_free);
  55
  56 static void vacuum_candidate_hasmap_free(Hashmap *h) {
  57         struct vacuum_candidate *c;
  58
  59         while ((c = hashmap_steal_first(h)))
  60                 vacuum_candidate_free(c);
  61
  62         hashmap_free(h);
  63 }
  64
  65 DEFINE_TRIVIAL_CLEANUP_FUNC(Hashmap*, vacuum_candidate_hasmap_free);
  66
  67 static int uid_from_file_name(const char *filename, uid_t *uid) {
  68         const char *p, *e, *u;
  69
  70         p = startswith(filename, "core.");
  71         if (!p)
  72                 return -EINVAL;
  73
  74         /* Skip the comm field */
  75         p = strchr(p, '.');
  76         if (!p)
  77                 return -EINVAL;
  78         p++;
  79
  80         /* Find end up UID */
  81         e = strchr(p, '.');
  82         if (!e)
  83                 return -EINVAL;
  84
  85         u = strndupa(p, e-p);
  86         return parse_uid(u, uid);
  87 }
  88
  89 static bool vacuum_necessary(int fd, uint64_t sum, uint64_t keep_free, uint64_t max_use) {
  90         uint64_t fs_size = 0, fs_free = (uint64_t) -1;
  91         struct statvfs sv;
  92
  93         assert(fd >= 0);
  94
  95         if (fstatvfs(fd, &sv) >= 0) {
  96                 fs_size = sv.f_frsize * sv.f_blocks;
  97                 fs_free = sv.f_frsize * sv.f_bfree;
  98         }
  99
 100         if (max_use == (uint64_t) -1) {
 101
 102                 if (fs_size > 0) {
 103                         max_use = PAGE_ALIGN(fs_size / 10); /* 10% */
 104
 105                         if (max_use > DEFAULT_MAX_USE_UPPER)
 106                                 max_use = DEFAULT_MAX_USE_UPPER;
 107
 108                         if (max_use < DEFAULT_MAX_USE_LOWER)
 109                                 max_use = DEFAULT_MAX_USE_LOWER;
 110                 } else
 111                         max_use = DEFAULT_MAX_USE_LOWER;
 112         } else
 113                 max_use = PAGE_ALIGN(max_use);
 114
 115         if (max_use > 0 && sum > max_use)
 116                 return true;
 117
 118         if (keep_free == (uint64_t) -1) {
 119
 120                 if (fs_size > 0) {
 121                         keep_free = PAGE_ALIGN((fs_size * 3) / 20); /* 15% */
 122
 123                         if (keep_free > DEFAULT_KEEP_FREE_UPPER)
 124                                 keep_free = DEFAULT_KEEP_FREE_UPPER;
 125                 } else
 126                         keep_free = DEFAULT_KEEP_FREE;
 127         } else
 128                 keep_free = PAGE_ALIGN(keep_free);
 129
 130         if (keep_free > 0 && fs_free < keep_free)
 131                 return true;
 132
 133         return false;
 134 }
 135
 136 int coredump_vacuum(int exclude_fd, uint64_t keep_free, uint64_t max_use) {
 137         _cleanup_closedir_ DIR *d = NULL;
 138         struct stat exclude_st;
 139         int r;
 140
 141         if (keep_free == 0 && max_use == 0)
 142                 return 0;
 143
 144         if (exclude_fd >= 0) {
 145                 if (fstat(exclude_fd, &exclude_st) < 0)
 146                         return log_error_errno(errno, "Failed to fstat(): %m");
 147         }
 148
 149         /* This algorithm will keep deleting the oldest file of the
 150          * user with the most coredumps until we are back in the size
 151          * limits. Note that vacuuming for journal files is different,
 152          * because we rely on rate-limiting of the messages there,
 153          * to avoid being flooded. */
 154
 155         d = opendir("/var/lib/systemd/coredump");
 156         if (!d) {
 157                 if (errno == ENOENT)
 158                         return 0;
 159
 160                 return log_error_errno(errno, "Can't open coredump directory: %m");
 161         }
 162
 163         for (;;) {
 164                 _cleanup_(vacuum_candidate_hasmap_freep) Hashmap *h = NULL;
 165                 struct vacuum_candidate *worst = NULL;
 166                 struct dirent *de;
 167                 uint64_t sum = 0;
 168
 169                 rewinddir(d);
 170
 171                 FOREACH_DIRENT(de, d, goto fail) {
 172                         struct vacuum_candidate *c;
 173                         struct stat st;
 174                         uid_t uid;
 175                         usec_t t;
 176
 177                         r = uid_from_file_name(de->d_name, &uid);
 178                         if (r < 0)
 179                                 continue;
 180
 181                         if (fstatat(dirfd(d), de->d_name, &st, AT_NO_AUTOMOUNT|AT_SYMLINK_NOFOLLOW) < 0) {
 182                                 if (errno == ENOENT)
 183                                         continue;
 184
 185                                 log_warning_errno(errno, "Failed to stat /var/lib/systemd/coredump/%s: %m", de->d_name);
 186                                 continue;
 187                         }
 188
 189                         if (!S_ISREG(st.st_mode))
 190                                 continue;
 191
 192                         if (exclude_fd >= 0 &&
 193                             exclude_st.st_dev == st.st_dev &&
 194                             exclude_st.st_ino == st.st_ino)
 195                                 continue;
 196
 197                         r = hashmap_ensure_allocated(&h, NULL);
 198                         if (r < 0)
 199                                 return log_oom();
 200
 201                         t = timespec_load(&st.st_mtim);
 202
 203                         c = hashmap_get(h, UID_TO_PTR(uid));
 204                         if (c) {
 205
 206                                 if (t < c->oldest_mtime) {
 207                                         char *n;
 208
 209                                         n = strdup(de->d_name);
 210                                         if (!n)
 211                                                 return log_oom();
 212
 213                                         free(c->oldest_file);
 214                                         c->oldest_file = n;
 215                                         c->oldest_mtime = t;
 216                                 }
 217
 218                         } else {
 219                                 _cleanup_(vacuum_candidate_freep) struct vacuum_candidate *n = NULL;
 220
 221                                 n = new0(struct vacuum_candidate, 1);
 222                                 if (!n)
 223                                         return log_oom();
 224
 225                                 n->oldest_file = strdup(de->d_name);
 226                                 if (!n->oldest_file)
 227                                         return log_oom();
 228
 229                                 n->oldest_mtime = t;
 230
 231                                 r = hashmap_put(h, UID_TO_PTR(uid), n);
 232                                 if (r < 0)
 233                                         return log_oom();
 234
 235                                 c = n;
 236                                 n = NULL;
 237                         }
 238
 239                         c->n_files++;
 240
 241                         if (!worst ||
 242                             worst->n_files < c->n_files ||
 243                             (worst->n_files == c->n_files && c->oldest_mtime < worst->oldest_mtime))
 244                                 worst = c;
 245
 246                         sum += st.st_blocks * 512;
 247                 }
 248
 249                 if (!worst)
 250                         break;
 251
 252                 r = vacuum_necessary(dirfd(d), sum, keep_free, max_use);
 253                 if (r <= 0)
 254                         return r;
 255
 256                 if (unlinkat(dirfd(d), worst->oldest_file, 0) < 0) {
 257
 258                         if (errno == ENOENT)
 259                                 continue;
 260
 261                         return log_error_errno(errno, "Failed to remove file %s: %m", worst->oldest_file);
 262                 } else
 263                         log_info("Removed old coredump %s.", worst->oldest_file);
 264         }
 265
 266         return 0;
 267
 268 fail:
 269         return log_error_errno(errno, "Failed to read directory: %m");
 270 }