X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Freadahead%2Freadahead-collect.c;h=5d07f4704af0837a588d0cc1c5293e4ac72b4e3f;hb=c4b996bd8748d14d4bb298462a29fbd977fa6fef;hp=008ede3964996a5e85c33cdd02370d8f0c625052;hpb=3b2d5b02ae231f1d3eb0d96eb980155d7797304e;p=elogind.git diff --git a/src/readahead/readahead-collect.c b/src/readahead/readahead-collect.c index 008ede396..5d07f4704 100644 --- a/src/readahead/readahead-collect.c +++ b/src/readahead/readahead-collect.c @@ -43,6 +43,10 @@ #include #include +#ifdef HAVE_FANOTIFY_INIT +#include +#endif + #include #include "missing.h" @@ -62,10 +66,6 @@ * - does ioprio_set work with fadvise()? */ -static unsigned arg_files_max = 16*1024; -static off_t arg_file_size_max = READAHEAD_FILE_SIZE_MAX; -static usec_t arg_timeout = 2*USEC_PER_MINUTE; - static ReadaheadShared *shared = NULL; /* Avoid collisions with the NULL pointer */ @@ -86,6 +86,7 @@ static int pack_file(FILE *pack, const char *fn, bool on_btrfs) { void *start = MAP_FAILED; uint8_t *vec; uint32_t b, c; + uint64_t inode; size_t l, pages; bool mapped; int r = 0, fd = -1, k; @@ -93,7 +94,8 @@ static int pack_file(FILE *pack, const char *fn, bool on_btrfs) { assert(pack); assert(fn); - if ((fd = open(fn, O_RDONLY|O_CLOEXEC|O_NOATIME|O_NOCTTY|O_NOFOLLOW)) < 0) { + fd = open(fn, O_RDONLY|O_CLOEXEC|O_NOATIME|O_NOCTTY|O_NOFOLLOW); + if (fd < 0) { if (errno == ENOENT) return 0; @@ -106,7 +108,8 @@ static int pack_file(FILE *pack, const char *fn, bool on_btrfs) { goto finish; } - if ((k = file_verify(fd, fn, arg_file_size_max, &st)) <= 0) { + k = file_verify(fd, fn, arg_file_size_max, &st); + if (k <= 0) { r = k; goto finish; } @@ -115,14 +118,14 @@ static int pack_file(FILE *pack, const char *fn, bool on_btrfs) { btrfs_defrag(fd); l = PAGE_ALIGN(st.st_size); - if ((start = mmap(NULL, l, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) { + start = mmap(NULL, l, PROT_READ, MAP_SHARED, fd, 0); + if (start == MAP_FAILED) { log_warning("mmap(%s) failed: %m", fn); r = -errno; goto finish; } pages = l / page_size(); - vec = alloca(pages); memset(vec, 0, pages); if (mincore(start, l, vec) < 0) { @@ -134,6 +137,10 @@ static int pack_file(FILE *pack, const char *fn, bool on_btrfs) { fputs(fn, pack); fputc('\n', pack); + /* Store the inode, so that we notice when the file is deleted */ + inode = (uint64_t) st.st_ino; + fwrite(&inode, sizeof(inode), 1, pack); + mapped = false; for (c = 0; c < pages; c++) { bool new_mapped = !!(vec[c] & 1); @@ -233,10 +240,24 @@ static int collect(const char *root) { bool on_ssd, on_btrfs; struct statfs sfs; usec_t not_after; + uint64_t previous_block_readahead; + bool previous_block_readahead_set = false; assert(root); - write_one_line_file("/proc/self/oom_score_adj", "1000"); + if (asprintf(&pack_fn, "%s/.readahead", root) < 0) { + r = log_oom(); + goto finish; + } + + /* If there's no pack file yet we lower the kernel readahead + * so that mincore() is accurate. If there is a pack file + * already we assume it is accurate enough so that kernel + * readahead is never triggered. */ + previous_block_readahead_set = + access(pack_fn, F_OK) < 0 && + block_get_readahead(root, &previous_block_readahead) >= 0 && + block_set_readahead(root, 8*1024) >= 0; if (ioprio_set(IOPRIO_WHO_PROCESS, getpid(), IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0)) < 0) log_warning("Failed to set IDLE IO priority class: %m"); @@ -439,7 +460,7 @@ static int collect(const char *root) { log_warning("readlink(%s) failed: %s", fn, strerror(-k)); next_iteration: - if (m->fd) + if (m->fd >= 0) close_nointr_nofail(m->fd); } } @@ -458,22 +479,19 @@ done: on_btrfs = statfs(root, &sfs) >= 0 && (long) sfs.f_type == (long) BTRFS_SUPER_MAGIC; log_debug("On btrfs: %s", yes_no(on_btrfs)); - asprintf(&pack_fn, "%s/.readahead", root); - asprintf(&pack_fn_new, "%s/.readahead.new", root); - - if (!pack_fn || !pack_fn_new) { - log_error("Out of memory"); - r = -ENOMEM; + if (asprintf(&pack_fn_new, "%s/.readahead.new", root) < 0) { + r = log_oom(); goto finish; } - if (!(pack = fopen(pack_fn_new, "we"))) { + pack = fopen(pack_fn_new, "we"); + if (!pack) { log_error("Failed to open pack file: %m"); r = -errno; goto finish; } - fputs(CANONICAL_HOST "\n", pack); + fputs(CANONICAL_HOST READAHEAD_PACK_FILE_VERSION, pack); putc(on_ssd ? 'S' : 'R', pack); if (on_ssd || on_btrfs) { @@ -494,8 +512,7 @@ done: n = hashmap_size(files); if (!(ordered = new(struct item, n))) { - log_error("Out of memory"); - r = -ENOMEM; + r = log_oom(); goto finish; } @@ -551,7 +568,6 @@ finish: fclose(pack); unlink(pack_fn_new); } - free(pack_fn_new); free(pack_fn); @@ -560,111 +576,23 @@ finish: hashmap_free(files); - return r; -} - -static int help(void) { - - printf("%s [OPTIONS...] [DIRECTORY]\n\n" - "Collect read-ahead data on early boot.\n\n" - " -h --help Show this help\n" - " --max-files=INT Maximum number of files to read ahead\n" - " --max-file-size=BYTES Maximum size of files to read ahead\n" - " --timeout=USEC Maximum time to spend collecting data\n", - program_invocation_short_name); + if (previous_block_readahead_set) { + uint64_t bytes; - return 0; -} - -static int parse_argv(int argc, char *argv[]) { - - enum { - ARG_FILES_MAX = 0x100, - ARG_FILE_SIZE_MAX, - ARG_TIMEOUT - }; - - static const struct option options[] = { - { "help", no_argument, NULL, 'h' }, - { "files-max", required_argument, NULL, ARG_FILES_MAX }, - { "file-size-max", required_argument, NULL, ARG_FILE_SIZE_MAX }, - { "timeout", required_argument, NULL, ARG_TIMEOUT }, - { NULL, 0, NULL, 0 } - }; - - int c; - - assert(argc >= 0); - assert(argv); - - while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) { - - switch (c) { - - case 'h': - help(); - return 0; - - case ARG_FILES_MAX: - if (safe_atou(optarg, &arg_files_max) < 0 || arg_files_max <= 0) { - log_error("Failed to parse maximum number of files %s.", optarg); - return -EINVAL; - } - break; - - case ARG_FILE_SIZE_MAX: { - unsigned long long ull; - - if (safe_atollu(optarg, &ull) < 0 || ull <= 0) { - log_error("Failed to parse maximum file size %s.", optarg); - return -EINVAL; - } - - arg_file_size_max = (off_t) ull; - break; - } - - case ARG_TIMEOUT: - if (parse_usec(optarg, &arg_timeout) < 0 || arg_timeout <= 0) { - log_error("Failed to parse timeout %s.", optarg); - return -EINVAL; - } - - break; - - case '?': - return -EINVAL; - - default: - log_error("Unknown option code %c", c); - return -EINVAL; - } + /* Restore the original kernel readahead setting if we + * changed it, and nobody has overwritten it since + * yet. */ + if (block_get_readahead(root, &bytes) >= 0 && bytes == 8*1024) + block_set_readahead(root, previous_block_readahead); } - if (optind != argc && - optind != argc-1) { - help(); - return -EINVAL; - } - - return 1; + return r; } -int main(int argc, char *argv[]) { - int r; - const char *root; - - log_set_target(LOG_TARGET_AUTO); - log_parse_environment(); - log_open(); +int main_collect(const char *root) { - umask(0022); - - r = parse_argv(argc, argv); - if (r <= 0) - return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS; - - root = optind < argc ? argv[optind] : "/"; + if (!root) + root = "/"; /* Skip this step on read-only media. Note that we check the * underlying block device here, not he read-only flag of the @@ -673,23 +601,23 @@ int main(int argc, char *argv[]) { * device is theoretically writable. */ if (fs_on_read_only(root) > 0) { log_info("Disabling readahead collector due to read-only media."); - return 0; + return EXIT_SUCCESS; } if (!enough_ram()) { log_info("Disabling readahead collector due to low memory."); - return 0; + return EXIT_SUCCESS; } shared = shared_get(); if (!shared) - return 1; + return EXIT_FAILURE; shared->collect = getpid(); __sync_synchronize(); if (collect(root) < 0) - return 1; + return EXIT_FAILURE; - return 0; + return EXIT_SUCCESS; }