src/readahead/readahead-common.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 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 <errno.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <sys/sysinfo.h>
  26 #include <sys/inotify.h>
  27 #include <fcntl.h>
  28 #include <sys/mman.h>
  29 #include <unistd.h>
  30
  31 #include "log.h"
  32 #include "readahead-common.h"
  33 #include "util.h"
  34 #include "missing.h"
  35 #include "fileio.h"
  36 #include "libudev.h"
  37 #include "udev-util.h"
  38
  39 int file_verify(int fd, const char *fn, off_t file_size_max, struct stat *st) {
  40         assert(fd >= 0);
  41         assert(fn);
  42         assert(st);
  43
  44         if (fstat(fd, st) < 0) {
  45                 log_warning("fstat(%s) failed: %m", fn);
  46                 return -errno;
  47         }
  48
  49         if (!S_ISREG(st->st_mode)) {
  50                 log_debug("Not preloading special file %s", fn);
  51                 return 0;
  52         }
  53
  54         if (st->st_size <= 0 || st->st_size > file_size_max) {
  55                 assert_cc(sizeof(st->st_size) == 8);
  56                 log_debug("Not preloading file %s with size out of bounds %"PRIu64,
  57                           fn, st->st_size);
  58                 return 0;
  59         }
  60
  61         return 1;
  62 }
  63
  64 int fs_on_ssd(const char *p) {
  65         struct stat st;
  66         _cleanup_udev_unref_ struct udev *udev = NULL;
  67         _cleanup_udev_device_unref_ struct udev_device *udev_device = NULL;
  68         struct udev_device *look_at = NULL;
  69         const char *devtype, *rotational, *model, *id;
  70         int r;
  71
  72         assert(p);
  73
  74         if (stat(p, &st) < 0)
  75                 return -errno;
  76
  77         if (major(st.st_dev) == 0) {
  78                 _cleanup_fclose_ FILE *f = NULL;
  79                 int mount_id;
  80                 union file_handle_union h = { .handle.handle_bytes = MAX_HANDLE_SZ, };
  81
  82                 /* Might be btrfs, which exposes "ssd" as mount flag if it is on ssd.
  83                  *
  84                  * We first determine the mount ID here, if we can,
  85                  * and then lookup the mount ID in mountinfo to find
  86                  * the mount options. */
  87
  88                 r = name_to_handle_at(AT_FDCWD, p, &h.handle, &mount_id, AT_SYMLINK_FOLLOW);
  89                 if (r < 0)
  90                         return false;
  91
  92                 f = fopen("/proc/self/mountinfo", "re");
  93                 if (!f)
  94                         return false;
  95
  96                 for (;;) {
  97                         char line[LINE_MAX], *e;
  98                         _cleanup_free_ char *opts = NULL;
  99                         int mid;
 100
 101                         if (!fgets(line, sizeof(line), f))
 102                                 return false;
 103
 104                         truncate_nl(line);
 105
 106                         if (sscanf(line, "%i", &mid) != 1)
 107                                 continue;
 108
 109                         if (mid != mount_id)
 110                                 continue;
 111
 112                         e = strstr(line, " - ");
 113                         if (!e)
 114                                 continue;
 115
 116                         if (sscanf(e+3, "%*s %*s %ms", &opts) != 1)
 117                                 continue;
 118
 119                         if (streq(opts, "ssd") || startswith(opts, "ssd,") || endswith(opts, ",ssd") || strstr(opts, ",ssd,"))
 120                                 return true;
 121                 }
 122
 123                 return false;
 124         }
 125
 126         udev = udev_new();
 127         if (!udev)
 128                 return -ENOMEM;
 129
 130         udev_device = udev_device_new_from_devnum(udev, 'b', st.st_dev);
 131         if (!udev_device)
 132                 return false;
 133
 134         devtype = udev_device_get_property_value(udev_device, "DEVTYPE");
 135         if (devtype && streq(devtype, "partition"))
 136                 look_at = udev_device_get_parent(udev_device);
 137         else
 138                 look_at = udev_device;
 139
 140         if (!look_at)
 141                 return false;
 142
 143         /* First, try high-level property */
 144         id = udev_device_get_property_value(look_at, "ID_SSD");
 145         if (id)
 146                 return streq(id, "1");
 147
 148         /* Second, try kernel attribute */
 149         rotational = udev_device_get_sysattr_value(look_at, "queue/rotational");
 150         if (rotational)
 151                 return streq(rotational, "0");
 152
 153         /* Finally, fallback to heuristics */
 154         look_at = udev_device_get_parent(look_at);
 155         if (!look_at)
 156                 return false;
 157
 158         model = udev_device_get_sysattr_value(look_at, "model");
 159         if (model)
 160                 return !!strstr(model, "SSD");
 161
 162         return false;
 163 }
 164
 165 int fs_on_read_only(const char *p) {
 166         struct stat st;
 167         _cleanup_udev_unref_ struct udev *udev = NULL;
 168         _cleanup_udev_device_unref_ struct udev_device *udev_device = NULL;
 169         const char *read_only;
 170
 171         assert(p);
 172
 173         if (stat(p, &st) < 0)
 174                 return -errno;
 175
 176         if (major(st.st_dev) == 0)
 177                 return false;
 178
 179         udev = udev_new();
 180         if (!udev)
 181                 return -ENOMEM;
 182
 183         udev_device = udev_device_new_from_devnum(udev, 'b', st.st_dev);
 184         if (!udev_device)
 185                 return false;
 186
 187         read_only = udev_device_get_sysattr_value(udev_device, "ro");
 188         if (read_only)
 189                 return streq(read_only, "1");
 190
 191         return false;
 192 }
 193
 194 bool enough_ram(void) {
 195         struct sysinfo si;
 196
 197         assert_se(sysinfo(&si) >= 0);
 198
 199         /* Enable readahead only with at least 128MB memory */
 200         return si.totalram > 127 * 1024*1024 / si.mem_unit;
 201 }
 202
 203 static void mkdirs(void) {
 204         if (mkdir("/run/systemd", 0755) && errno != EEXIST)
 205                 log_warning("Failed to create /run/systemd: %m");
 206         if (mkdir("/run/systemd/readahead", 0755) && errno != EEXIST)
 207                 log_warning("Failed to create /run/systemd: %m");
 208 }
 209
 210 int open_inotify(void) {
 211         int fd;
 212
 213         fd = inotify_init1(IN_CLOEXEC|IN_NONBLOCK);
 214         if (fd < 0) {
 215                 log_error("Failed to create inotify handle: %m");
 216                 return -errno;
 217         }
 218
 219         mkdirs();
 220
 221         if (inotify_add_watch(fd, "/run/systemd/readahead", IN_CREATE) < 0) {
 222                 log_error("Failed to watch /run/systemd/readahead: %m");
 223                 safe_close(fd);
 224                 return -errno;
 225         }
 226
 227         return fd;
 228 }
 229
 230 ReadaheadShared *shared_get(void) {
 231         _cleanup_close_ int fd = -1;
 232         ReadaheadShared *m = NULL;
 233
 234         mkdirs();
 235
 236         fd = open("/run/systemd/readahead/shared", O_CREAT|O_RDWR|O_CLOEXEC, 0644);
 237         if (fd < 0) {
 238                 log_error("Failed to create shared memory segment: %m");
 239                 return NULL;
 240         }
 241
 242         if (ftruncate(fd, sizeof(ReadaheadShared)) < 0) {
 243                 log_error("Failed to truncate shared memory segment: %m");
 244                 return NULL;
 245         }
 246
 247         m = mmap(NULL, sizeof(ReadaheadShared), PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
 248         if (m == MAP_FAILED) {
 249                 log_error("Failed to mmap shared memory segment: %m");
 250                 return NULL;
 251         }
 252
 253         return m;
 254 }
 255
 256 /* We use 20K instead of the more human digestable 16K here. Why?
 257    Simply so that it is more unlikely that users end up picking this
 258    value too so that we can recognize better whether the user changed
 259    the value while we had it temporarily bumped. */
 260 #define BUMP_REQUEST_NR (20*1024u)
 261
 262 int block_bump_request_nr(const char *p) {
 263         struct stat st;
 264         uint64_t u;
 265         char *ap = NULL, *line = NULL;
 266         int r;
 267         dev_t d;
 268
 269         assert(p);
 270
 271         if (stat(p, &st) < 0)
 272                 return -errno;
 273
 274         if (major(st.st_dev) == 0)
 275                 return 0;
 276
 277         d = st.st_dev;
 278         block_get_whole_disk(d, &d);
 279
 280         if (asprintf(&ap, "/sys/dev/block/%u:%u/queue/nr_requests", major(d), minor(d)) < 0) {
 281                 r= -ENOMEM;
 282                 goto finish;
 283         }
 284
 285         r = read_one_line_file(ap, &line);
 286         if (r < 0) {
 287                 if (r == -ENOENT)
 288                         r = 0;
 289                 goto finish;
 290         }
 291
 292         r = safe_atou64(line, &u);
 293         if (r >= 0 && u >= BUMP_REQUEST_NR) {
 294                 r = 0;
 295                 goto finish;
 296         }
 297
 298         free(line);
 299         line = NULL;
 300
 301         if (asprintf(&line, "%u", BUMP_REQUEST_NR) < 0) {
 302                 r = -ENOMEM;
 303                 goto finish;
 304         }
 305
 306         r = write_string_file(ap, line);
 307         if (r < 0)
 308                 goto finish;
 309
 310         log_info("Bumped block_nr parameter of %u:%u to %u. This is a temporary hack and should be removed one day.", major(d), minor(d), BUMP_REQUEST_NR);
 311         r = 1;
 312
 313 finish:
 314         free(ap);
 315         free(line);
 316
 317         return r;
 318 }
 319
 320 int block_get_readahead(const char *p, uint64_t *bytes) {
 321         struct stat st;
 322         char *ap = NULL, *line = NULL;
 323         int r;
 324         dev_t d;
 325         uint64_t u;
 326
 327         assert(p);
 328         assert(bytes);
 329
 330         if (stat(p, &st) < 0)
 331                 return -errno;
 332
 333         if (major(st.st_dev) == 0)
 334                 return 0;
 335
 336         d = st.st_dev;
 337         block_get_whole_disk(d, &d);
 338
 339         if (asprintf(&ap, "/sys/dev/block/%u:%u/bdi/read_ahead_kb", major(d), minor(d)) < 0) {
 340                 r = -ENOMEM;
 341                 goto finish;
 342         }
 343
 344         r = read_one_line_file(ap, &line);
 345         if (r < 0)
 346                 goto finish;
 347
 348         r = safe_atou64(line, &u);
 349         if (r < 0)
 350                 goto finish;
 351
 352         *bytes = u * 1024ULL;
 353
 354 finish:
 355         free(ap);
 356         free(line);
 357
 358         return r;
 359 }
 360
 361 int block_set_readahead(const char *p, uint64_t bytes) {
 362         struct stat st;
 363         char *ap = NULL, *line = NULL;
 364         int r;
 365         dev_t d;
 366
 367         assert(p);
 368         assert(bytes);
 369
 370         if (stat(p, &st) < 0)
 371                 return -errno;
 372
 373         if (major(st.st_dev) == 0)
 374                 return 0;
 375
 376         d = st.st_dev;
 377         block_get_whole_disk(d, &d);
 378
 379         if (asprintf(&ap, "/sys/dev/block/%u:%u/bdi/read_ahead_kb", major(d), minor(d)) < 0) {
 380                 r = -ENOMEM;
 381                 goto finish;
 382         }
 383
 384         if (asprintf(&line, "%llu", bytes / 1024ULL) < 0) {
 385                 r = -ENOMEM;
 386                 goto finish;
 387         }
 388
 389         r = write_string_file(ap, line);
 390         if (r < 0)
 391                 goto finish;
 392
 393 finish:
 394         free(ap);
 395         free(line);
 396
 397         return r;
 398 }