From: Lennart Poettering Date: Fri, 21 Sep 2012 18:52:23 +0000 (+0200) Subject: journal: completely rework the mmap cache as I too dumb to actually understand it X-Git-Tag: v191~5 X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=commitdiff_plain;h=f801968466fed39d50d410b30ac828c26722cc95;ds=sidebyside journal: completely rework the mmap cache as I too dumb to actually understand it Instead of doing hand optimized fd bisect arrays just use plain old hashmaps. Now I can understand my own code again. Yay! As a side effect this should fix some bad memory accesses caused by accesses after mmap(), introduced in 189. --- diff --git a/Makefile.am b/Makefile.am index d9049bbed..357a0b0bc 100644 --- a/Makefile.am +++ b/Makefile.am @@ -2473,6 +2473,13 @@ test_journal_verify_LDADD = \ libsystemd-journal-internal.la \ libsystemd-id128-internal.la +test_mmap_cache_SOURCES = \ + src/journal/test-mmap-cache.c + +test_mmap_cache_LDADD = \ + libsystemd-shared.la \ + libsystemd-journal-internal.la + libsystemd_journal_la_SOURCES = \ src/journal/sd-journal.c \ src/systemd/sd-journal.h \ @@ -2577,13 +2584,15 @@ noinst_PROGRAMS += \ test-journal-send \ test-journal-match \ test-journal-stream \ - test-journal-verify + test-journal-verify \ + test-mmap-cache TESTS += \ test-journal \ test-journal-match \ test-journal-stream \ - test-journal-verify + test-journal-verify \ + test-mmap-cache pkginclude_HEADERS += \ src/systemd/sd-journal.h \ diff --git a/TODO b/TODO index 051d22bc3..77d2375ce 100644 --- a/TODO +++ b/TODO @@ -19,6 +19,11 @@ F18: Features: +* document that deps in [Unit] sections ignore Alias= fileds in + [Install] units of other units, unless those units are disabled + +* need to update LGPL2.1 text to newest version (with updated FSF address) + * allow users from "wheel" to start/stop services * systemctl: when powering down/suspending check for inhibitors, and warn. diff --git a/src/core/service.c b/src/core/service.c index 7c79dcdd1..8d315c1f7 100644 --- a/src/core/service.c +++ b/src/core/service.c @@ -1829,7 +1829,6 @@ static int service_spawn( if (r < 0) goto fail; - if ((r = unit_watch_pid(UNIT(s), pid)) < 0) /* FIXME: we need to do something here */ goto fail; diff --git a/src/journal/mmap-cache.c b/src/journal/mmap-cache.c index 7d6c6c22b..4be3f7e96 100644 --- a/src/journal/mmap-cache.c +++ b/src/journal/mmap-cache.c @@ -19,357 +19,428 @@ along with systemd; If not, see . ***/ -#include -#include #include #include +#include #include +#include "hashmap.h" +#include "list.h" +#include "log.h" #include "util.h" - +#include "macro.h" #include "mmap-cache.h" -#define WINDOW_SIZE (8ULL*1024ULL*1024ULL) +typedef struct Window Window; +typedef struct Context Context; +typedef struct FileDescriptor FileDescriptor; -#define DEFAULT_WINDOWS_MAX 64 -#define DEFAULT_FDS_MAX 32 -#define DEFAULT_CONTEXTS_MAX 32 +struct Window { + MMapCache *cache; + + bool keep_always; + bool in_unused; -typedef struct Window { - int fd; void *ptr; uint64_t offset; - uint64_t size; + int prot; + size_t size; + + FileDescriptor *fd; - unsigned n_ref; - unsigned lru_prev; - unsigned lru_next; + LIST_FIELDS(Window, by_fd); + LIST_FIELDS(Window, unused); + + LIST_HEAD(Context, contexts); +}; - unsigned by_fd_prev; - unsigned by_fd_next; -} Window; +struct Context { + MMapCache *cache; + unsigned id; + Window *window; -typedef struct FileDescriptor { + LIST_FIELDS(Context, by_window); +}; + +struct FileDescriptor { + MMapCache *cache; int fd; - unsigned windows; -} FileDescriptor; + LIST_HEAD(Window, windows); +}; struct MMapCache { - unsigned n_ref; + int n_ref; - unsigned contexts_max; - unsigned windows_max; - unsigned fds_max; + Hashmap *fds; + Hashmap *contexts; unsigned n_windows; - unsigned n_fds; - - unsigned lru_first, lru_last; - Window *windows; - unsigned *by_context; - FileDescriptor *by_fd; + LIST_HEAD(Window, unused); + Window *last_unused; }; -static int mmap_cache_peek_fd_index(MMapCache *m, int fd, unsigned *fd_index); - -static void mmap_cache_window_unmap(MMapCache *m, unsigned w) { - Window *v; +#define WINDOWS_MIN 64 +#define WINDOW_SIZE (8ULL*1024ULL*1024ULL) - assert(m); - assert(w < m->n_windows); +MMapCache* mmap_cache_new(void) { + MMapCache *m; - v = m->windows + w; - if (!v->ptr) - return; + m = new0(MMapCache, 1); + if (!m) + return NULL; - munmap(v->ptr, v->size); - v->ptr = NULL; + m->n_ref = 1; + return m; } -static void mmap_cache_window_add_lru(MMapCache *m, unsigned w) { - Window *v; - +MMapCache* mmap_cache_ref(MMapCache *m) { assert(m); - assert(w < m->n_windows); + assert(m->n_ref > 0); - v = m->windows + w; - assert(v->n_ref == 0); + m->n_ref ++; + return m; +} - if (m->lru_last != (unsigned) -1) { - assert(m->windows[m->lru_last].lru_next == (unsigned) -1); - m->windows[m->lru_last].lru_next = w; - } +static void window_unlink(Window *w) { + Context *c; - v->lru_prev = m->lru_last; - v->lru_next = (unsigned) -1; + assert(w); - m->lru_last = w; - if (m->lru_first == (unsigned) -1) - m->lru_first = w; -} + if (w->ptr) + munmap(w->ptr, w->size); -static void mmap_cache_window_remove_lru(MMapCache *m, unsigned w) { - Window *v; + if (w->fd) + LIST_REMOVE(Window, by_fd, w->fd->windows, w); - assert(m); - assert(w < m->n_windows); + if (w->in_unused) { + if (w->cache->last_unused == w) + w->cache->last_unused = w->unused_prev; - v = m->windows + w; - - if (v->lru_prev == (unsigned) -1) { - assert(m->lru_first == w); - m->lru_first = v->lru_next; - } else { - assert(m->windows[v->lru_prev].lru_next == w); - m->windows[v->lru_prev].lru_next = v->lru_next; + LIST_REMOVE(Window, unused, w->cache->unused, w); } - if (v->lru_next == (unsigned) -1) { - assert(m->lru_last == w); - m->lru_last = v->lru_prev; - } else { - assert(m->windows[v->lru_next].lru_prev == w); - m->windows[v->lru_next].lru_prev = v->lru_prev; + LIST_FOREACH(by_window, c, w->contexts) { + assert(c->window == w); + c->window = NULL; } } -static void mmap_cache_fd_add(MMapCache *m, unsigned fd_index, unsigned w) { - Window *v; - - assert(m); - assert(fd_index < m->n_fds); - - v = m->windows + w; - assert(m->by_fd[fd_index].fd == v->fd); +static void window_free(Window *w) { + assert(w); - if (m->by_fd[fd_index].windows != (unsigned) -1) { - assert(m->windows[m->by_fd[fd_index].windows].by_fd_prev == (unsigned) -1); - m->windows[m->by_fd[fd_index].windows].by_fd_prev = w; - } + window_unlink(w); + free(w); +} - v->by_fd_next = m->by_fd[fd_index].windows; - v->by_fd_prev = (unsigned) -1; +static bool window_matches(Window *w, int fd, int prot, uint64_t offset, size_t size) { + assert(w); + assert(fd >= 0); + assert(size > 0); - m->by_fd[fd_index].windows = w; + return + w->fd && + fd == w->fd->fd && + prot == w->prot && + offset >= w->offset && + offset + size <= w->offset + w->size; } -static void mmap_cache_fd_remove(MMapCache *m, unsigned fd_index, unsigned w) { - Window *v; +static Window *window_add(MMapCache *m) { + Window *w; assert(m); - assert(fd_index < m->n_fds); - v = m->windows + w; - assert(m->by_fd[fd_index].fd == v->fd); - assert(v->by_fd_next == (unsigned) -1 || m->windows[v->by_fd_next].fd == v->fd); - assert(v->by_fd_prev == (unsigned) -1 || m->windows[v->by_fd_prev].fd == v->fd); + if (!m->last_unused || m->n_windows <= WINDOWS_MIN) { - if (v->by_fd_prev == (unsigned) -1) { - assert(m->by_fd[fd_index].windows == w); - m->by_fd[fd_index].windows = v->by_fd_next; + /* Allocate a new window */ + w = new0(Window, 1); + if (!w) + return NULL; } else { - assert(m->windows[v->by_fd_prev].by_fd_next == w); - m->windows[v->by_fd_prev].by_fd_next = v->by_fd_next; - } - if (v->by_fd_next != (unsigned) -1) { - assert(m->windows[v->by_fd_next].by_fd_prev == w); - m->windows[v->by_fd_next].by_fd_prev = v->by_fd_prev; + /* Reuse an existing one */ + w = m->last_unused; + window_unlink(w); + zero(*w); } + + w->cache = m; + return w; } -static void mmap_cache_context_unset(MMapCache *m, unsigned c) { - Window *v; - unsigned w; +static void context_detach_window(Context *c) { + Window *w; - assert(m); - assert(c < m->contexts_max); + assert(c); - if (m->by_context[c] == (unsigned) -1) + if (!c->window) return; - w = m->by_context[c]; - m->by_context[c] = (unsigned) -1; + w = c->window; + c->window = NULL; + LIST_REMOVE(Context, by_window, w->contexts, c); - v = m->windows + w; - assert(v->n_ref > 0); - v->n_ref --; + if (!w->contexts) { + /* Not used anymore? */ + LIST_PREPEND(Window, unused, c->cache->unused, w); + if (!c->cache->last_unused) + c->cache->last_unused = w; - if (v->n_ref == 0) - mmap_cache_window_add_lru(m, w); + w->in_unused = true; + } } -static void mmap_cache_context_set(MMapCache *m, unsigned c, unsigned w) { - Window *v; - - assert(m); - assert(c < m->contexts_max); - assert(w < m->n_windows); +static void context_attach_window(Context *c, Window *w) { + assert(c); + assert(w); - if (m->by_context[c] == w) + if (c->window == w) return; - mmap_cache_context_unset(m, c); + context_detach_window(c); - m->by_context[c] = w; + if (!w->contexts) { + /* Used again? */ + LIST_REMOVE(Window, unused, c->cache->unused, w); + if (!c->cache->last_unused) + c->cache->last_unused = w; - v = m->windows + w; - v->n_ref ++; + w->in_unused = false; + } - if (v->n_ref == 1) - mmap_cache_window_remove_lru(m, w); + c->window = w; + LIST_PREPEND(Context, by_window, w->contexts, c); } -static void mmap_cache_free(MMapCache *m) { +static Context *context_add(MMapCache *m, unsigned id) { + Context *c; + int r; assert(m); - if (m->windows) { - unsigned w; + c = hashmap_get(m->contexts, UINT_TO_PTR(id + 1)); + if (c) + return c; + + r = hashmap_ensure_allocated(&m->contexts, trivial_hash_func, trivial_compare_func); + if (r < 0) + return NULL; + + c = new0(Context, 1); + if (!c) + return NULL; - for (w = 0; w < m->n_windows; w++) - mmap_cache_window_unmap(m, w); + c->cache = m; + c->id = id; - free(m->windows); + r = hashmap_put(m->contexts, UINT_TO_PTR(id + 1), c); + if (r < 0) { + free(c); + return NULL; } - free(m->by_context); - free(m->by_fd); - free(m); + return c; } -MMapCache* mmap_cache_new(void) { - MMapCache *m; +static void context_free(Context *c) { + assert(c); - m = new0(MMapCache, 1); - if (!m) - return NULL; + context_detach_window(c); - m->contexts_max = DEFAULT_CONTEXTS_MAX; - m->fds_max = DEFAULT_FDS_MAX; - m->windows_max = DEFAULT_WINDOWS_MAX; - m->n_ref = 1; - m->lru_first = (unsigned) -1; - m->lru_last = (unsigned) -1; + if (c->cache) + assert_se(hashmap_remove(c->cache->contexts, UINT_TO_PTR(c->id + 1))); - m->windows = new(Window, m->windows_max); - if (!m->windows) { - mmap_cache_free(m); + free(c); +} + +static void fd_free(FileDescriptor *f) { + assert(f); + + while (f->windows) + window_free(f->windows); + + if (f->cache) + assert_se(hashmap_remove(f->cache->fds, INT_TO_PTR(f->fd + 1))); + + free(f); +} + +static FileDescriptor* fd_add(MMapCache *m, int fd) { + FileDescriptor *f; + int r; + + assert(m); + assert(fd >= 0); + + f = hashmap_get(m->fds, INT_TO_PTR(fd + 1)); + if (f) + return f; + + r = hashmap_ensure_allocated(&m->fds, trivial_hash_func, trivial_compare_func); + if (r < 0) return NULL; - } - m->by_context = new(unsigned, m->contexts_max); - if (!m->by_context) { - mmap_cache_free(m); + f = new0(FileDescriptor, 1); + if (!f) return NULL; - } - memset(m->by_context, -1, m->contexts_max * sizeof(unsigned)); - m->by_fd = new(FileDescriptor, m->fds_max); - if (!m->by_fd) { - mmap_cache_free(m); + f->cache = m; + f->fd = fd; + + r = hashmap_put(m->fds, UINT_TO_PTR(fd + 1), f); + if (r < 0) { + free(f); return NULL; } - return m; + return f; } -MMapCache* mmap_cache_ref(MMapCache *m) { +static void mmap_cache_free(MMapCache *m) { + Context *c; + FileDescriptor *f; + assert(m); - assert(m->n_ref > 0); - m->n_ref++; - return m; + while ((c = hashmap_first(m->contexts))) + context_free(c); + + while ((f = hashmap_first(m->fds))) + fd_free(f); + + while (m->unused) + window_free(m->unused); + + free(m); } MMapCache* mmap_cache_unref(MMapCache *m) { assert(m); assert(m->n_ref > 0); - if (m->n_ref == 1) + m->n_ref --; + if (m->n_ref == 0) mmap_cache_free(m); - else - m->n_ref--; return NULL; } -static int mmap_cache_allocate_window(MMapCache *m, unsigned *w) { - Window *v; - unsigned fd_index; +static int make_room(MMapCache *m) { + assert(m); + + if (!m->last_unused) + return 0; + + window_free(m->last_unused); + return 1; +} + +static int try_context( + MMapCache *m, + int fd, + int prot, + unsigned context, + bool keep_always, + uint64_t offset, + size_t size, + void **ret) { + + Context *c; assert(m); - assert(w); + assert(m->n_ref > 0); + assert(fd >= 0); + assert(size > 0); + assert(ret); - if (m->n_windows < m->windows_max) { - *w = m->n_windows ++; + c = hashmap_get(m->contexts, UINT_TO_PTR(context+1)); + if (!c) return 0; - } - if (m->lru_first == (unsigned) -1) - return -E2BIG; + assert(c->id == context); - *w = m->lru_first; - v = m->windows + *w; - assert(v->n_ref == 0); + if (!c->window) + return 0; - mmap_cache_window_unmap(m, *w); + if (!window_matches(c->window, fd, prot, offset, size)) { - if (v->fd >= 0) { - assert_se(mmap_cache_peek_fd_index(m, v->fd, &fd_index) > 0); - mmap_cache_fd_remove(m, fd_index, *w); + /* Drop the reference to the window, since it's unnecessary now */ + context_detach_window(c); + return 0; } - mmap_cache_window_remove_lru(m, *w); + c->window->keep_always = c->window->keep_always || keep_always; - return 0; + *ret = (uint8_t*) c->window->ptr + (offset - c->window->offset); + return 1; } -static int mmap_cache_make_room(MMapCache *m) { - unsigned w; +static int find_mmap( + MMapCache *m, + int fd, + int prot, + unsigned context, + bool keep_always, + uint64_t offset, + size_t size, + void **ret) { + + FileDescriptor *f; + Window *w; + Context *c; assert(m); + assert(m->n_ref > 0); + assert(fd >= 0); + assert(size > 0); + assert(ret); - w = m->lru_first; - while (w != (unsigned) -1) { - Window *v; + f = hashmap_get(m->fds, INT_TO_PTR(fd + 1)); + if (!f) + return 0; - v = m->windows + w; - assert(v->n_ref == 0); + assert(f->fd == fd); - if (v->ptr) { - mmap_cache_window_unmap(m, w); - return 1; - } + LIST_FOREACH(by_fd, w, f->windows) + if (window_matches(w, fd, prot, offset, size)) + break; - w = v->lru_next; - } + if (!w) + return 0; + + c = context_add(m, context); + if (!c) + return -ENOMEM; + + context_attach_window(c, w); + w->keep_always = w->keep_always || keep_always; - return 0; + *ret = (uint8_t*) w->ptr + (offset - w->offset); + return 1; } -static int mmap_cache_put( +static int add_mmap( MMapCache *m, int fd, - unsigned fd_index, int prot, unsigned context, bool keep_always, uint64_t offset, - uint64_t size, + size_t size, struct stat *st, void **ret) { - unsigned w; - Window *v; - void *d; uint64_t woffset, wsize; + Context *c; + FileDescriptor *f; + Window *w; + void *d; int r; assert(m); + assert(m->n_ref > 0); assert(fd >= 0); - assert(context < m->contexts_max); assert(size > 0); assert(ret); @@ -409,190 +480,39 @@ static int mmap_cache_put( if (errno != ENOMEM) return -errno; - r = mmap_cache_make_room(m); + r = make_room(m); if (r < 0) return r; if (r == 0) return -ENOMEM; } - r = mmap_cache_allocate_window(m, &w); - if (r < 0) { - munmap(d, wsize); - return r; - } - - v = m->windows + w; - v->fd = fd; - v->ptr = d; - v->offset = woffset; - v->size = wsize; - - if (keep_always) - v->n_ref = 1; - else { - v->n_ref = 0; - mmap_cache_window_add_lru(m, w); - } - - mmap_cache_fd_add(m, fd_index, w); - mmap_cache_context_set(m, context, w); - - *ret = (uint8_t*) d + (offset - woffset); - return 1; -} - -static int fd_cmp(const void *_a, const void *_b) { - const FileDescriptor *a = _a, *b = _b; - - if (a->fd < b->fd) - return -1; - if (a->fd > b->fd) - return 1; - - return 0; -} - -static int mmap_cache_peek_fd_index(MMapCache *m, int fd, unsigned *fd_index) { - FileDescriptor *j; - unsigned r; - - assert(m); - assert(fd >= 0); - assert(fd_index); - - for (r = 0; r < m->n_fds; r++) - assert(m->by_fd[r].windows == (unsigned) -1 || - m->windows[m->by_fd[r].windows].fd == m->by_fd[r].fd); - - j = bsearch(&fd, m->by_fd, m->n_fds, sizeof(FileDescriptor), fd_cmp); - if (!j) - return 0; - - *fd_index = (unsigned) (j - m->by_fd); - return 1; -} - -static int mmap_cache_get_fd_index(MMapCache *m, int fd, unsigned *fd_index) { - FileDescriptor *j; - int r; - - assert(m); - assert(fd >= 0); - assert(fd_index); - - r = mmap_cache_peek_fd_index(m, fd, fd_index); - if (r != 0) - return r; - - if (m->n_fds >= m->fds_max) { - unsigned k; - FileDescriptor *n; - - k = m->n_fds * 2; - n = realloc(m->by_fd, sizeof(FileDescriptor) * k); - if (!n) - return -ENOMEM; - - m->fds_max = k; - m->by_fd = n; - } - - j = m->by_fd + m->n_fds ++; - j->fd = fd; - j->windows = (unsigned) -1; - - qsort(m->by_fd, m->n_fds, sizeof(FileDescriptor), fd_cmp); - - return mmap_cache_peek_fd_index(m, fd, fd_index); -} - -static bool mmap_cache_test_window( - MMapCache *m, - unsigned w, - uint64_t offset, - uint64_t size) { - Window *v; - - assert(m); - assert(w < m->n_windows); - assert(size > 0); - - v = m->windows + w; - - return offset >= v->offset && - offset + size <= v->offset + v->size; -} + c = context_add(m, context); + if (!c) + return -ENOMEM; -static int mmap_cache_current( - MMapCache *m, - int fd, - unsigned context, - uint64_t offset, - uint64_t size, - void **ret) { + f = fd_add(m, fd); + if (!f) + return -ENOMEM; - Window *v; - unsigned w; + w = window_add(m); + if (!w) + return -ENOMEM; - assert(m); - assert(fd >= 0); - assert(context < m->contexts_max); - assert(size > 0); - assert(ret); - - if (m->by_context[context] == (unsigned) -1) - return 0; - - w = m->by_context[context]; - v = m->windows + w; + w->keep_always = keep_always; + w->ptr = d; + w->offset = woffset; + w->prot = prot; + w->size = wsize; + w->fd = f; - if (v->fd != fd) - return 0; + LIST_PREPEND(Window, by_fd, f->windows, w); - if (!mmap_cache_test_window(m, w, offset, size)) - return 0; + context_detach_window(c); + c->window = w; + LIST_PREPEND(Context, by_window, w->contexts, c); - *ret = (uint8_t*) v->ptr + (offset - v->offset); - return 1; -} - -static int mmap_cache_find( - MMapCache *m, - int fd, - unsigned fd_index, - unsigned context, - uint64_t offset, - uint64_t size, - void **ret) { - - Window *v = NULL; - unsigned w; - - assert(m); - assert(fd >= 0); - assert(fd_index < m->n_fds); - assert(context < m->contexts_max); - assert(size > 0); - assert(ret); - - w = m->by_fd[fd_index].windows; - while (w != (unsigned) -1) { - v = m->windows + w; - assert(v->fd == fd); - - if (mmap_cache_test_window(m, w, offset, size)) - break; - - w = v->by_fd_next; - } - - if (w == (unsigned) -1) - return 0; - - mmap_cache_context_set(m, context, w); - - *ret = (uint8_t*) v->ptr + (offset - v->offset); + *ret = (uint8_t*) w->ptr + (offset - w->offset); return 1; } @@ -603,104 +523,53 @@ int mmap_cache_get( unsigned context, bool keep_always, uint64_t offset, - uint64_t size, + size_t size, struct stat *st, void **ret) { - unsigned fd_index; int r; assert(m); + assert(m->n_ref > 0); assert(fd >= 0); assert(size > 0); assert(ret); - if (context >= m->contexts_max) { - unsigned k, *n; - Window *w; - - /* Increase the number of contexts if necessary, and - * make sure we have twice the number of windows */ - - k = context * 2; - n = realloc(m->by_context, sizeof(unsigned) * k); - if (!n) - return -ENOMEM; - memset(n + m->contexts_max, -1, (k - m->contexts_max) * sizeof(unsigned)); - m->contexts_max = k; - m->by_context = n; - - k = MAX(m->windows_max, m->contexts_max*2); - w = realloc(m->windows, sizeof(Window) * k); - if (!w) - return -ENOMEM; - - m->windows_max = k; - m->windows = w; - } - - /* Maybe the current pointer for this context is already the - * right one? */ - r = mmap_cache_current(m, fd, context, offset, size, ret); + /* Check whether the current context is the right one already */ + r = try_context(m, fd, prot, context, keep_always, offset, size, ret); if (r != 0) return r; - /* Hmm, drop the reference to the current one, since it wasn't - * good enough */ - mmap_cache_context_unset(m, context); - - /* OK, let's find the chain for this FD */ - r = mmap_cache_get_fd_index(m, fd, &fd_index); - if (r < 0) - return r; - - /* And let's look through the available mmaps */ - r = mmap_cache_find(m, fd, fd_index, context, offset, size, ret); + /* Search for a matching mmap */ + r = find_mmap(m, fd, prot, context, keep_always, offset, size, ret); if (r != 0) return r; - /* Not found? Then, let's add it */ - return mmap_cache_put(m, fd, fd_index, prot, context, keep_always, offset, size, st, ret); + /* Create a new mmap */ + return add_mmap(m, fd, prot, context, keep_always, offset, size, st, ret); } void mmap_cache_close_fd(MMapCache *m, int fd) { - unsigned fd_index, c, w; - int r; + FileDescriptor *f; assert(m); - assert(fd > 0); + assert(fd >= 0); - r = mmap_cache_peek_fd_index(m, fd, &fd_index); - if (r <= 0) + f = hashmap_get(m->fds, INT_TO_PTR(fd + 1)); + if (!f) return; - for (c = 0; c < m->contexts_max; c++) { - w = m->by_context[c]; - if (w == (unsigned) -1) - continue; - - if (m->windows[w].fd == fd) - mmap_cache_context_unset(m, c); - } - - w = m->by_fd[fd_index].windows; - while (w != (unsigned) -1) { - Window *v; - - v = m->windows + w; - assert(v->fd == fd); + fd_free(f); +} - mmap_cache_window_unmap(m, w); - mmap_cache_fd_remove(m, fd_index, w); - v->fd = -1; +void mmap_cache_close_context(MMapCache *m, unsigned context) { + Context *c; - w = m->by_fd[fd_index].windows; - } + assert(m); - memmove(m->by_fd + fd_index, m->by_fd + fd_index + 1, (m->n_fds - (fd_index + 1)) * sizeof(FileDescriptor)); - m->n_fds --; -} + c = hashmap_get(m->contexts, UINT_TO_PTR(context + 1)); + if (!c) + return; -void mmap_cache_close_context(MMapCache *m, unsigned context) { - mmap_cache_context_unset(m, context); + context_free(c); } diff --git a/src/journal/mmap-cache.h b/src/journal/mmap-cache.h index 98a1a731f..de3463408 100644 --- a/src/journal/mmap-cache.h +++ b/src/journal/mmap-cache.h @@ -22,6 +22,8 @@ ***/ #include +#include +#include typedef struct MMapCache MMapCache;