#include "mmap-cache.h"
#define WINDOW_SIZE (8ULL*1024ULL*1024ULL)
-#define WINDOWS_MAX 32
+
+#define DEFAULT_WINDOWS_MAX 64
+#define DEFAULT_FDS_MAX 32
+#define DEFAULT_CONTEXTS_MAX 32
typedef struct Window {
int fd;
FileDescriptor *by_fd;
};
+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;
assert(w < m->n_windows);
v = m->windows + w;
+ assert(v->n_ref == 0);
+
+ if (m->lru_last != (unsigned) -1) {
+ assert(m->windows[m->lru_last].lru_next == (unsigned) -1);
+ m->windows[m->lru_last].lru_next = w;
+ }
+
v->lru_prev = m->lru_last;
v->lru_next = (unsigned) -1;
v = m->windows + w;
- if (v->lru_prev == (unsigned) -1)
+ if (v->lru_prev == (unsigned) -1) {
+ assert(m->lru_first == w);
m->lru_first = v->lru_next;
- else
+ } else {
+ assert(m->windows[v->lru_prev].lru_next == w);
m->windows[v->lru_prev].lru_next = v->lru_next;
+ }
- if (v->lru_next == (unsigned) -1)
+ if (v->lru_next == (unsigned) -1) {
+ assert(m->lru_last == w);
m->lru_last = v->lru_prev;
- else
+ } else {
+ assert(m->windows[v->lru_next].lru_prev == w);
m->windows[v->lru_next].lru_prev = v->lru_prev;
+ }
}
static void mmap_cache_fd_add(MMapCache *m, unsigned fd_index, unsigned w) {
assert(fd_index < m->n_fds);
v = m->windows + w;
+ assert(m->by_fd[fd_index].fd == v->fd);
+
+ 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;
+ }
+
v->by_fd_next = m->by_fd[fd_index].windows;
v->by_fd_prev = (unsigned) -1;
assert(fd_index < m->n_fds);
v = m->windows + w;
- if (v->by_fd_prev == (unsigned) -1)
+ 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 (v->by_fd_prev == (unsigned) -1) {
+ assert(m->by_fd[fd_index].windows == w);
m->by_fd[fd_index].windows = v->by_fd_next;
- else
+ } 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)
+ 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;
+ }
}
static void mmap_cache_context_unset(MMapCache *m, unsigned c) {
v = m->windows + w;
v->n_ref ++;
+
if (v->n_ref == 1)
mmap_cache_window_remove_lru(m, w);
}
free(m);
}
-MMapCache* mmap_cache_new(unsigned contexts_max, unsigned fds_max) {
+MMapCache* mmap_cache_new(void) {
MMapCache *m;
- assert(contexts_max > 0);
- assert(fds_max > 0);
-
m = new0(MMapCache, 1);
if (!m)
return NULL;
- m->contexts_max = contexts_max;
- m->fds_max = fds_max;
- m->windows_max = MAX(m->contexts_max, WINDOWS_MAX);
+ 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;
}
static int mmap_cache_allocate_window(MMapCache *m, unsigned *w) {
+ Window *v;
+ unsigned fd_index;
+
assert(m);
assert(w);
return -E2BIG;
*w = m->lru_first;
+ v = m->windows + *w;
+ assert(v->n_ref == 0);
+
mmap_cache_window_unmap(m, *w);
+
+ 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);
+ }
+
mmap_cache_window_remove_lru(m, *w);
return 0;
Window *v;
v = m->windows + w;
+ assert(v->n_ref == 0);
if (v->ptr) {
mmap_cache_window_unmap(m, w);
unsigned fd_index,
int prot,
unsigned context,
+ bool keep_always,
uint64_t offset,
uint64_t size,
+ struct stat *st,
void **ret) {
unsigned w;
wsize = WINDOW_SIZE;
}
+ if (st) {
+ /* Memory maps that are larger then the files
+ underneath have undefined behaviour. Hence, clamp
+ things to the file size if we know it */
+
+ if (woffset >= (uint64_t) st->st_size)
+ return -EADDRNOTAVAIL;
+
+ if (woffset + wsize > (uint64_t) st->st_size)
+ wsize = PAGE_ALIGN(st->st_size - woffset);
+ }
+
for (;;) {
d = mmap(NULL, wsize, prot, MAP_SHARED, fd, woffset);
if (d != MAP_FAILED)
v->offset = woffset;
v->size = wsize;
- v->n_ref = 0;
- v->lru_prev = v->lru_next = (unsigned) -1;
+ 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);
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);
- j = bsearch(&fd, m->by_fd, m->n_fds, sizeof(m->by_fd[0]), fd_cmp);
- if (!j) {
- if (m->n_fds >= m->fds_max)
- return -E2BIG;
+ 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;
- j = m->by_fd + m->n_fds ++;
- j->fd = fd;
- j->windows = (unsigned) -1;
+ k = m->n_fds * 2;
+ n = realloc(m->by_fd, sizeof(FileDescriptor) * k);
+ if (!n)
+ return -ENOMEM;
- qsort(m->by_fd, m->n_fds, sizeof(m->by_fd[0]), fd_cmp);
- j = bsearch(&fd, m->by_fd, m->n_fds, sizeof(m->by_fd[0]), fd_cmp);
+ m->fds_max = k;
+ m->by_fd = n;
}
- *fd_index = (unsigned) (j - m->by_fd);
- return 0;
+ 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(
static int mmap_cache_find(
MMapCache *m,
+ int fd,
unsigned fd_index,
unsigned context,
uint64_t offset,
unsigned w;
assert(m);
+ assert(fd >= 0);
assert(fd_index < m->n_fds);
assert(context < m->contexts_max);
assert(size > 0);
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 = m->windows[w].by_fd_next;
+ w = v->by_fd_next;
}
if (w == (unsigned) -1)
mmap_cache_context_set(m, context, w);
- v = m->windows + w;
*ret = (uint8_t*) v->ptr + (offset - v->offset);
return 1;
}
int fd,
int prot,
unsigned context,
+ bool keep_always,
uint64_t offset,
uint64_t size,
+ struct stat *st,
void **ret) {
unsigned fd_index;
assert(m);
assert(fd >= 0);
- assert(context < m->contexts_max);
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);
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_index, context, offset, size, ret);
+ r = mmap_cache_find(m, fd, fd_index, context, 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, offset, size, ret);
+ return mmap_cache_put(m, fd, fd_index, prot, context, keep_always, offset, size, st, ret);
}
void mmap_cache_close_fd(MMapCache *m, int fd) {
- FileDescriptor *j;
unsigned fd_index, c, w;
+ int r;
assert(m);
assert(fd > 0);
- j = bsearch(&fd, m->by_fd, m->n_fds, sizeof(m->by_fd[0]), fd_cmp);
- if (!j)
+ r = mmap_cache_peek_fd_index(m, fd, &fd_index);
+ if (r <= 0)
return;
- fd_index = (unsigned) (j - m->by_fd);
for (c = 0; c < m->contexts_max; c++) {
w = m->by_context[c];
w = m->by_fd[fd_index].windows;
while (w != (unsigned) -1) {
+ Window *v;
+
+ v = m->windows + w;
+ assert(v->fd == fd);
- mmap_cache_fd_remove(m, fd_index, w);
mmap_cache_window_unmap(m, w);
+ mmap_cache_fd_remove(m, fd_index, w);
+ v->fd = -1;
w = m->by_fd[fd_index].windows;
}