X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Freadahead-common.c;h=85e3227f6e50d520e7972a0b1d23fe2b9905d323;hp=8533717d479ae7aa8befb3b4812aea5b537ec649;hb=62347bc24a695bc0527f663af5fe136b1a993573;hpb=22be093ffb403a1c474037939ca9b88b1ee39f77

diff --git a/src/readahead-common.c b/src/readahead-common.c
index 8533717d4..85e3227f6 100644
--- a/src/readahead-common.c
+++ b/src/readahead-common.c
@@ -20,15 +20,20 @@
 ***/
 
 #include <errno.h>
-#include <libudev.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/sysinfo.h>
+#include <sys/inotify.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <libudev.h>
 
 #include "log.h"
 #include "readahead-common.h"
 #include "util.h"
 
-int file_verify(int fd, const char *fn, struct stat *st) {
+int file_verify(int fd, const char *fn, off_t file_size_max, struct stat *st) {
         assert(fd >= 0);
         assert(fn);
         assert(st);
@@ -43,8 +48,8 @@ int file_verify(int fd, const char *fn, struct stat *st) {
                 return 0;
         }
 
-        if (st->st_size <= 0 || st->st_size > READAHEAD_FILE_SIZE_MAX) {
-                log_debug("Not preloading file %s with size out of bounds %zi", fn, st->st_size);
+        if (st->st_size <= 0 || st->st_size > file_size_max) {
+                log_debug("Not preloading file %s with size out of bounds %llu", fn, (unsigned long long) st->st_size);
                 return 0;
         }
 
@@ -63,6 +68,9 @@ int fs_on_ssd(const char *p) {
         if (stat(p, &st) < 0)
                 return -errno;
 
+        if (major(st.st_dev) == 0)
+                return false;
+
         if (!(udev = udev_new()))
                 return -ENOMEM;
 
@@ -105,3 +113,135 @@ finish:
 
         return b;
 }
+
+bool enough_ram(void) {
+        struct sysinfo si;
+
+        assert_se(sysinfo(&si) >= 0);
+
+        return si.totalram > 127 * 1024*1024; /* Enable readahead only
+                                               * with at least 128MB
+                                               * memory */
+}
+
+int open_inotify(void) {
+        int fd;
+
+        if ((fd = inotify_init1(IN_CLOEXEC|IN_NONBLOCK)) < 0) {
+                log_error("Failed to create inotify handle: %m");
+                return -errno;
+        }
+
+        mkdir("/dev/.systemd", 0755);
+        mkdir("/dev/.systemd/readahead", 0755);
+
+        if (inotify_add_watch(fd, "/dev/.systemd/readahead", IN_CREATE) < 0) {
+                log_error("Failed to watch /dev/.systemd/readahead: %m");
+                close_nointr_nofail(fd);
+                return -errno;
+        }
+
+        return fd;
+}
+
+ReadaheadShared *shared_get(void) {
+        int fd;
+        ReadaheadShared *m = NULL;
+
+        mkdir("/dev/.systemd", 0755);
+        mkdir("/dev/.systemd/readahead", 0755);
+
+        if ((fd = open("/dev/.systemd/readahead/shared", O_CREAT|O_RDWR|O_CLOEXEC, 0644)) < 0) {
+                log_error("Failed to create shared memory segment: %m");
+                goto finish;
+        }
+
+        if (ftruncate(fd, sizeof(ReadaheadShared)) < 0) {
+                log_error("Failed to truncate shared memory segment: %m");
+                goto finish;
+        }
+
+        if ((m = mmap(NULL, sizeof(ReadaheadShared), PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+                log_error("Failed to mmap shared memory segment: %m");
+                m = NULL;
+                goto finish;
+        }
+
+finish:
+        if (fd >= 0)
+                close_nointr_nofail(fd);
+
+        return m;
+}
+
+
+#define BUMP_REQUEST_NR (16*1024)
+
+int bump_request_nr(const char *p) {
+        struct stat st;
+        struct udev *udev = NULL;
+        struct udev_device *udev_device = NULL, *look_at = NULL;
+        const char *nr_requests;
+        uint64_t u;
+        char nr[64], *ap = NULL;
+        int r;
+
+        assert(p);
+
+        if (stat(p, &st) < 0)
+                return -errno;
+
+        if (major(st.st_dev) == 0)
+                return 0;
+
+        if (!(udev = udev_new()))
+                return -ENOMEM;
+
+        if (!(udev_device = udev_device_new_from_devnum(udev, 'b', st.st_dev))) {
+                r = -ENOENT;
+                goto finish;
+        }
+
+        look_at = udev_device;
+        if (!(nr_requests = udev_device_get_sysattr_value(look_at, "queue/nr_requests"))) {
+
+                /* Hmm, if the block device doesn't have a queue
+                 * subdir, the let's look in the parent */
+                look_at = udev_device_get_parent(udev_device);
+                nr_requests = udev_device_get_sysattr_value(look_at, "queue/nr_requests");
+        }
+
+        if (!nr_requests) {
+                r = -ENOENT;
+                goto finish;
+        }
+
+        if (safe_atou64(nr_requests, &u) >= 0 && u >= BUMP_REQUEST_NR) {
+                r = 0;
+                goto finish;
+        }
+
+        if (asprintf(&ap, "%s/queue/nr_requests", udev_device_get_syspath(look_at)) < 0) {
+                r = -ENOMEM;
+                goto finish;
+        }
+
+        snprintf(nr, sizeof(nr), "%lu", (unsigned long) BUMP_REQUEST_NR);
+
+        if ((r = write_one_line_file(ap, nr)) < 0)
+                goto finish;
+
+        log_info("Bumped block_nr parameter of %s to %lu. This is a temporary hack and should be removed one day.", udev_device_get_devnode(look_at), (unsigned long) BUMP_REQUEST_NR);
+        r = 1;
+
+finish:
+        if (udev_device)
+                udev_device_unref(udev_device);
+
+        if (udev)
+                udev_unref(udev);
+
+        free(ap);
+
+        return r;
+}