/* cache.c: cache management
*
- * Copyright (C) 2006 Lars Hjemli
+ * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>
*
* Licensed under GNU General Public License v2
* (see COPYING for full license text)
#include "cgit.h"
#include "cache.h"
#include "html.h"
+#ifdef HAVE_LINUX_SENDFILE
+#include <sys/sendfile.h>
+#endif
#define CACHE_BUFSIZE (1024 * 4)
struct cache_slot {
const char *key;
- int keylen;
+ size_t keylen;
int ttl;
cache_fill_fn fn;
- void *cbdata;
int cache_fd;
int lock_fd;
const char *cache_name;
const char *lock_name;
int match;
struct stat cache_st;
- struct stat lock_st;
int bufsize;
char buf[CACHE_BUFSIZE];
};
static int open_slot(struct cache_slot *slot)
{
char *bufz;
- int bufkeylen = -1;
+ ssize_t bufkeylen = -1;
slot->cache_fd = open(slot->cache_name, O_RDONLY);
if (slot->cache_fd == -1)
if (bufz)
bufkeylen = bufz - slot->buf;
- slot->match = bufkeylen == slot->keylen &&
- !memcmp(slot->key, slot->buf, bufkeylen + 1);
+ if (slot->key)
+ slot->match = bufkeylen == slot->keylen &&
+ !memcmp(slot->key, slot->buf, bufkeylen + 1);
return 0;
}
/* Print the content of the active cache slot (but skip the key). */
static int print_slot(struct cache_slot *slot)
{
+#ifdef HAVE_LINUX_SENDFILE
+ off_t start_off;
+ int ret;
+
+ start_off = slot->keylen + 1;
+
+ do {
+ ret = sendfile(STDOUT_FILENO, slot->cache_fd, &start_off,
+ slot->cache_st.st_size - start_off);
+ if (ret < 0) {
+ if (errno == EAGAIN || errno == EINTR)
+ continue;
+ return errno;
+ }
+ return 0;
+ } while (1);
+#else
ssize_t i, j;
i = lseek(slot->cache_fd, slot->keylen + 1, SEEK_SET);
return errno;
else
return 0;
+#endif
}
/* Check if the slot has expired */
*/
static int lock_slot(struct cache_slot *slot)
{
- slot->lock_fd = open(slot->lock_name, O_RDWR | O_CREAT | O_EXCL,
+ struct flock lock = {
+ .l_type = F_WRLCK,
+ .l_whence = SEEK_SET,
+ .l_start = 0,
+ .l_len = 0,
+ };
+
+ slot->lock_fd = open(slot->lock_name, O_RDWR | O_CREAT,
S_IRUSR | S_IWUSR);
if (slot->lock_fd == -1)
return errno;
+ if (fcntl(slot->lock_fd, F_SETLK, &lock) < 0) {
+ int saved_errno = errno;
+ close(slot->lock_fd);
+ slot->lock_fd = -1;
+ return saved_errno;
+ }
if (xwrite(slot->lock_fd, slot->key, slot->keylen + 1) < 0)
return errno;
return 0;
return errno;
/* Redirect stdout to lockfile */
- if (dup2(slot->lock_fd, STDOUT_FILENO) == -1)
+ if (dup2(slot->lock_fd, STDOUT_FILENO) == -1) {
+ close(tmp);
return errno;
+ }
/* Generate cache content */
- slot->fn(slot->cbdata);
+ slot->fn();
+
+ /* Make sure any buffered data is flushed to the file */
+ if (fflush(stdout)) {
+ close(tmp);
+ return errno;
+ }
+
+ /* update stat info */
+ if (fstat(slot->lock_fd, &slot->cache_st)) {
+ close(tmp);
+ return errno;
+ }
/* Restore stdout */
- if (dup2(tmp, STDOUT_FILENO) == -1)
+ if (dup2(tmp, STDOUT_FILENO) == -1) {
+ close(tmp);
return errno;
+ }
/* Close the temporary filedescriptor */
if (close(tmp))
/* If the cache slot does not exist (or its key doesn't match the
* current key), lets try to create a new cache slot for this
* request. If this fails (for whatever reason), lets just generate
- * the content without caching it and fool the caller to belive
+ * the content without caching it and fool the caller to believe
* everything worked out (but print a warning on stdout).
*/
if ((err = lock_slot(slot)) != 0) {
cache_log("[cgit] Unable to lock slot %s: %s (%d)\n",
slot->lock_name, strerror(err), err);
- slot->fn(slot->cbdata);
+ slot->fn();
return 0;
}
slot->lock_name, strerror(err), err);
unlock_slot(slot, 0);
close_lock(slot);
- slot->fn(slot->cbdata);
+ slot->fn();
return 0;
}
// We've got a valid cache slot in the lock file, which
/* Print cached content to stdout, generate the content if necessary. */
int cache_process(int size, const char *path, const char *key, int ttl,
- cache_fill_fn fn, void *cbdata)
+ cache_fill_fn fn)
{
unsigned long hash;
int i;
int result;
/* If the cache is disabled, just generate the content */
- if (size <= 0) {
- fn(cbdata);
+ if (size <= 0 || ttl == 0) {
+ fn();
return 0;
}
/* Verify input, calculate filenames */
if (!path) {
cache_log("[cgit] Cache path not specified, caching is disabled\n");
- fn(cbdata);
+ fn();
return 0;
}
if (!key)
strbuf_addbuf(&lockname, &filename);
strbuf_addstr(&lockname, ".lock");
slot.fn = fn;
- slot.cbdata = cbdata;
slot.ttl = ttl;
slot.cache_name = filename.buf;
slot.lock_name = lockname.buf;
DIR *dir;
struct dirent *ent;
int err = 0;
- struct cache_slot slot;
+ struct cache_slot slot = { NULL };
struct strbuf fullname = STRBUF_INIT;
size_t prefixlen;
git.ckatri.com / cgit.git / blobdiff