X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fjournal%2Fmmap-cache.c;h=22f75540b83f948d0d7e3604b4317c22ed809baa;hp=f34d260856127e6493ff08db3ba5052515f25f47;hb=b6e676ce41508e2aeea22202fc8f234126177f52;hpb=1b8951e5bd9b2bf1722098a861055cae0bb52088 diff --git a/src/journal/mmap-cache.c b/src/journal/mmap-cache.c index f34d26085..22f75540b 100644 --- a/src/journal/mmap-cache.c +++ b/src/journal/mmap-cache.c @@ -22,13 +22,13 @@ #include #include #include -#include #include "hashmap.h" #include "list.h" #include "log.h" #include "util.h" #include "macro.h" +#include "sigbus.h" #include "mmap-cache.h" typedef struct Window Window; @@ -38,6 +38,7 @@ typedef struct FileDescriptor FileDescriptor; struct Window { MMapCache *cache; + bool invalidated; bool keep_always; bool in_unused; @@ -65,6 +66,7 @@ struct Context { struct FileDescriptor { MMapCache *cache; int fd; + bool sigbus; LIST_HEAD(Window, windows); }; @@ -76,7 +78,7 @@ struct MMapCache { Hashmap *fds; - Hashmap *contexts; + Context *contexts[MMAP_CACHE_MAX_CONTEXTS]; LIST_HEAD(Window, unused); Window *last_unused; @@ -134,6 +136,21 @@ static void window_unlink(Window *w) { } } +static void window_invalidate(Window *w) { + assert(w); + + if (w->invalidated) + return; + + /* Replace the window with anonymous pages. This is useful + * when we hit a SIGBUS and want to make sure the file cannot + * trigger any further SIGBUS, possibly overrunning the sigbus + * queue. */ + + assert_se(mmap(w->ptr, w->size, w->prot, MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0) == w->ptr); + w->invalidated = true; +} + static void window_free(Window *w) { assert(w); @@ -231,18 +248,13 @@ static void context_attach_window(Context *c, Window *w) { static Context *context_add(MMapCache *m, unsigned id) { Context *c; - int r; assert(m); - c = hashmap_get(m->contexts, UINT_TO_PTR(id + 1)); + c = m->contexts[id]; if (c) return c; - r = hashmap_ensure_allocated(&m->contexts, NULL); - if (r < 0) - return NULL; - c = new0(Context, 1); if (!c) return NULL; @@ -250,11 +262,8 @@ static Context *context_add(MMapCache *m, unsigned id) { c->cache = m; c->id = id; - r = hashmap_put(m->contexts, UINT_TO_PTR(id + 1), c); - if (r < 0) { - free(c); - return NULL; - } + assert(!m->contexts[id]); + m->contexts[id] = c; return c; } @@ -264,8 +273,10 @@ static void context_free(Context *c) { context_detach_window(c); - if (c->cache) - assert_se(hashmap_remove(c->cache->contexts, UINT_TO_PTR(c->id + 1))); + if (c->cache) { + assert(c->cache->contexts[c->id] == c); + c->cache->contexts[c->id] = NULL; + } free(c); } @@ -314,15 +325,14 @@ static FileDescriptor* fd_add(MMapCache *m, int fd) { } static void mmap_cache_free(MMapCache *m) { - Context *c; FileDescriptor *f; + int i; assert(m); - while ((c = hashmap_first(m->contexts))) - context_free(c); - - hashmap_free(m->contexts); + for (i = 0; i < MMAP_CACHE_MAX_CONTEXTS; i++) + if (m->contexts[i]) + context_free(m->contexts[i]); while ((f = hashmap_first(m->fds))) fd_free(f); @@ -374,7 +384,7 @@ static int try_context( assert(size > 0); assert(ret); - c = hashmap_get(m->contexts, UINT_TO_PTR(context+1)); + c = m->contexts[context]; if (!c) return 0; @@ -390,6 +400,9 @@ static int try_context( return 0; } + if (c->window->fd->sigbus) + return -EIO; + c->window->keep_always |= keep_always; *ret = (uint8_t*) c->window->ptr + (offset - c->window->offset); @@ -421,6 +434,9 @@ static int find_mmap( assert(f->fd == fd); + if (f->sigbus) + return -EIO; + LIST_FOREACH(by_fd, w, f->windows) if (window_matches(w, fd, prot, offset, size)) break; @@ -557,6 +573,7 @@ int mmap_cache_get( assert(fd >= 0); assert(size > 0); assert(ret); + assert(context < MMAP_CACHE_MAX_CONTEXTS); /* Check whether the current context is the right one already */ r = try_context(m, fd, prot, context, keep_always, offset, size, ret); @@ -578,39 +595,111 @@ int mmap_cache_get( return add_mmap(m, fd, prot, context, keep_always, offset, size, st, ret); } -void mmap_cache_close_fd(MMapCache *m, int fd) { - FileDescriptor *f; - +unsigned mmap_cache_get_hit(MMapCache *m) { assert(m); - assert(fd >= 0); - f = hashmap_get(m->fds, INT_TO_PTR(fd + 1)); - if (!f) - return; + return m->n_hit; +} - fd_free(f); +unsigned mmap_cache_get_missed(MMapCache *m) { + assert(m); + + return m->n_missed; } -void mmap_cache_close_context(MMapCache *m, unsigned context) { - Context *c; +static void mmap_cache_process_sigbus(MMapCache *m) { + bool found = false; + FileDescriptor *f; + Iterator i; + int r; assert(m); - c = hashmap_get(m->contexts, UINT_TO_PTR(context + 1)); - if (!c) + /* Iterate through all triggered pages and mark their files as + * invalidated */ + for (;;) { + bool ours; + void *addr; + + r = sigbus_pop(&addr); + if (_likely_(r == 0)) + break; + if (r < 0) { + log_error_errno(r, "SIGBUS handling failed: %m"); + abort(); + } + + ours = false; + HASHMAP_FOREACH(f, m->fds, i) { + Window *w; + + LIST_FOREACH(by_fd, w, f->windows) { + if ((uint8_t*) addr >= (uint8_t*) w->ptr && + (uint8_t*) addr < (uint8_t*) w->ptr + w->size) { + found = ours = f->sigbus = true; + break; + } + } + + if (ours) + break; + } + + /* Didn't find a matching window, give up */ + if (!ours) { + log_error("Unknown SIGBUS page, aborting."); + abort(); + } + } + + /* The list of triggered pages is now empty. Now, let's remap + * all windows of the triggered file to anonymous maps, so + * that no page of the file in question is triggered again, so + * that we can be sure not to hit the queue size limit. */ + if (_likely_(!found)) return; - context_free(c); + HASHMAP_FOREACH(f, m->fds, i) { + Window *w; + + if (!f->sigbus) + continue; + + LIST_FOREACH(by_fd, w, f->windows) + window_invalidate(w); + } } -unsigned mmap_cache_get_hit(MMapCache *m) { +bool mmap_cache_got_sigbus(MMapCache *m, int fd) { + FileDescriptor *f; + assert(m); + assert(fd >= 0); - return m->n_hit; + mmap_cache_process_sigbus(m); + + f = hashmap_get(m->fds, INT_TO_PTR(fd + 1)); + if (!f) + return false; + + return f->sigbus; } -unsigned mmap_cache_get_missed(MMapCache *m) { +void mmap_cache_close_fd(MMapCache *m, int fd) { + FileDescriptor *f; + assert(m); + assert(fd >= 0); - return m->n_missed; + /* Make sure that any queued SIGBUS are first dispatched, so + * that we don't end up with a SIGBUS entry we cannot relate + * to any existing memory map */ + + mmap_cache_process_sigbus(m); + + f = hashmap_get(m->fds, INT_TO_PTR(fd + 1)); + if (!f) + return; + + fd_free(f); }