memcached-1.6.20/0000775000175000017500000000000014427544305010521 500000000000000memcached-1.6.20/util.c0000664000175000017500000001464214204760331011561 00000000000000#include #include #include #include #include #include #include #include "memcached.h" static char *uriencode_map[256]; static char uriencode_str[768]; void uriencode_init(void) { int x; char *str = uriencode_str; for (x = 0; x < 256; x++) { if (isalnum(x) || x == '-' || x == '.' || x == '_' || x == '~') { uriencode_map[x] = NULL; } else { snprintf(str, 4, "%%%02hhX", (unsigned char)x); uriencode_map[x] = str; str += 3; /* lobbing off the \0 is fine */ } } } bool uriencode(const char *src, char *dst, const size_t srclen, const size_t dstlen) { int x; size_t d = 0; for (x = 0; x < srclen; x++) { if (d + 4 > dstlen) return false; if (uriencode_map[(unsigned char) src[x]] != NULL) { memcpy(&dst[d], uriencode_map[(unsigned char) src[x]], 3); d += 3; } else { dst[d] = src[x]; d++; } } dst[d] = '\0'; return true; } /* Avoid warnings on solaris, where isspace() is an index into an array, and gcc uses signed chars */ #define xisspace(c) isspace((unsigned char)c) bool safe_strtoull(const char *str, uint64_t *out) { assert(out != NULL); errno = 0; *out = 0; char *endptr; unsigned long long ull = strtoull(str, &endptr, 10); if ((errno == ERANGE) || (str == endptr)) { return false; } if (xisspace(*endptr) || (*endptr == '\0' && endptr != str)) { if ((long long) ull < 0) { /* only check for negative signs in the uncommon case when * the unsigned number is so big that it's negative as a * signed number. */ if (strchr(str, '-') != NULL) { return false; } } *out = ull; return true; } return false; } /* Could macro this. Decided to keep this unrolled for safety rather than add * the base parameter to all callers. Very few places need to parse a number * outside of base 10, currently exactly once, so splitting this up should * help avoid typo bugs. */ bool safe_strtoull_hex(const char *str, uint64_t *out) { assert(out != NULL); errno = 0; *out = 0; char *endptr; unsigned long long ull = strtoull(str, &endptr, 16); if ((errno == ERANGE) || (str == endptr)) { return false; } if (xisspace(*endptr) || (*endptr == '\0' && endptr != str)) { if ((long long) ull < 0) { /* only check for negative signs in the uncommon case when * the unsigned number is so big that it's negative as a * signed number. */ if (strchr(str, '-') != NULL) { return false; } } *out = ull; return true; } return false; } bool safe_strtoll(const char *str, int64_t *out) { assert(out != NULL); errno = 0; *out = 0; char *endptr; long long ll = strtoll(str, &endptr, 10); if ((errno == ERANGE) || (str == endptr)) { return false; } if (xisspace(*endptr) || (*endptr == '\0' && endptr != str)) { *out = ll; return true; } return false; } bool safe_strtoul(const char *str, uint32_t *out) { char *endptr = NULL; unsigned long l = 0; assert(out); assert(str); *out = 0; errno = 0; l = strtoul(str, &endptr, 10); if ((errno == ERANGE) || (str == endptr)) { return false; } if (xisspace(*endptr) || (*endptr == '\0' && endptr != str)) { if ((long) l < 0) { /* only check for negative signs in the uncommon case when * the unsigned number is so big that it's negative as a * signed number. */ if (strchr(str, '-') != NULL) { return false; } } *out = l; return true; } return false; } bool safe_strtol(const char *str, int32_t *out) { assert(out != NULL); errno = 0; *out = 0; char *endptr; long l = strtol(str, &endptr, 10); if ((errno == ERANGE) || (str == endptr)) { return false; } if (xisspace(*endptr) || (*endptr == '\0' && endptr != str)) { *out = l; return true; } return false; } bool safe_strtod(const char *str, double *out) { assert(out != NULL); errno = 0; *out = 0; char *endptr; double d = strtod(str, &endptr); if ((errno == ERANGE) || (str == endptr)) { return false; } if (xisspace(*endptr) || (*endptr == '\0' && endptr != str)) { *out = d; return true; } return false; } // slow, safe function for copying null terminated buffers. // ensures null terminator set on destination buffer. copies at most dstmax-1 // non-null bytes. // Explicitly avoids over-reading src while looking for the null byte. // returns true if src was fully copied. // returns false if src was truncated into dst. bool safe_strcpy(char *dst, const char *src, const size_t dstmax) { size_t x; for (x = 0; x < dstmax - 1 && src[x] != '\0'; x++) { dst[x] = src[x]; } dst[x] = '\0'; if (src[x] == '\0') { return true; } else { return false; } } bool safe_memcmp(const void *a, const void *b, size_t len) { const volatile unsigned char *ua = (const volatile unsigned char *)a; const volatile unsigned char *ub = (const volatile unsigned char *)b; int delta = 0; size_t x; for (x = 0; x < len; x++) { delta |= ua[x] ^ ub[x]; } if (delta == 0) { return true; } else { return false; } } void vperror(const char *fmt, ...) { int old_errno = errno; char buf[1024]; va_list ap; va_start(ap, fmt); if (vsnprintf(buf, sizeof(buf), fmt, ap) == -1) { buf[sizeof(buf) - 1] = '\0'; } va_end(ap); errno = old_errno; perror(buf); } #ifndef HAVE_HTONLL static uint64_t mc_swap64(uint64_t in) { #ifdef ENDIAN_LITTLE /* Little endian, flip the bytes around until someone makes a faster/better * way to do this. */ int64_t rv = 0; int i = 0; for(i = 0; i<8; i++) { rv = (rv << 8) | (in & 0xff); in >>= 8; } return rv; #else /* big-endian machines don't need byte swapping */ return in; #endif } uint64_t ntohll(uint64_t val) { return mc_swap64(val); } uint64_t htonll(uint64_t val) { return mc_swap64(val); } #endif memcached-1.6.20/extstore.c0000664000175000017500000010006014357451302012453 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "config.h" // FIXME: config.h? #include #include // end FIXME #include #include #include #include #include #include #include #include #include #include #include #include "extstore.h" // TODO: better if an init option turns this on/off. #ifdef EXTSTORE_DEBUG #define E_DEBUG(...) \ do { \ fprintf(stderr, __VA_ARGS__); \ } while (0) #else #define E_DEBUG(...) #endif #define STAT_L(e) pthread_mutex_lock(&e->stats_mutex); #define STAT_UL(e) pthread_mutex_unlock(&e->stats_mutex); #define STAT_INCR(e, stat, amount) { \ pthread_mutex_lock(&e->stats_mutex); \ e->stats.stat += amount; \ pthread_mutex_unlock(&e->stats_mutex); \ } #define STAT_DECR(e, stat, amount) { \ pthread_mutex_lock(&e->stats_mutex); \ e->stats.stat -= amount; \ pthread_mutex_unlock(&e->stats_mutex); \ } typedef struct __store_wbuf { struct __store_wbuf *next; char *buf; char *buf_pos; unsigned int free; unsigned int size; unsigned int offset; /* offset into page this write starts at */ bool full; /* done writing to this page */ bool flushed; /* whether wbuf has been flushed to disk */ } _store_wbuf; typedef struct _store_page { pthread_mutex_t mutex; /* Need to be held for most operations */ uint64_t obj_count; /* _delete can decrease post-closing */ uint64_t bytes_used; /* _delete can decrease post-closing */ uint64_t offset; /* starting address of page within fd */ unsigned int version; unsigned int refcount; unsigned int allocated; unsigned int written; /* item offsets can be past written if wbuf not flushed */ unsigned int bucket; /* which bucket the page is linked into */ unsigned int free_bucket; /* which bucket this page returns to when freed */ int fd; unsigned short id; bool active; /* actively being written to */ bool closed; /* closed and draining before free */ bool free; /* on freelist */ _store_wbuf *wbuf; /* currently active wbuf from the stack */ struct _store_page *next; } store_page; typedef struct store_engine store_engine; typedef struct { pthread_mutex_t mutex; pthread_cond_t cond; obj_io *queue; obj_io *queue_tail; store_engine *e; unsigned int depth; // queue depth } store_io_thread; typedef struct { pthread_mutex_t mutex; pthread_cond_t cond; store_engine *e; } store_maint_thread; struct store_engine { pthread_mutex_t mutex; /* covers internal stacks and variables */ store_page *pages; /* directly addressable page list */ _store_wbuf *wbuf_stack; /* wbuf freelist */ obj_io *io_stack; /* IO's to use with submitting wbuf's */ store_io_thread *io_threads; store_maint_thread *maint_thread; store_page *page_freelist; store_page **page_buckets; /* stack of pages currently allocated to each bucket */ store_page **free_page_buckets; /* stack of use-case isolated free pages */ size_t page_size; unsigned int version; /* global version counter */ unsigned int last_io_thread; /* round robin the IO threads */ unsigned int io_threadcount; /* count of IO threads */ unsigned int page_count; unsigned int page_free; /* unallocated pages */ unsigned int page_bucketcount; /* count of potential page buckets */ unsigned int free_page_bucketcount; /* count of free page buckets */ unsigned int io_depth; /* FIXME: Might cache into thr struct */ pthread_mutex_t stats_mutex; struct extstore_stats stats; }; // FIXME: code is duplicated from thread.c since extstore.c doesn't pull in // the memcached ecosystem. worth starting a cross-utility header with static // definitions/macros? // keeping a minimal func here for now. #define THR_NAME_MAXLEN 16 static void thread_setname(pthread_t thread, const char *name) { assert(strlen(name) < THR_NAME_MAXLEN); #if defined(__linux__) pthread_setname_np(thread, name); #endif } #undef THR_NAME_MAXLEN static _store_wbuf *wbuf_new(size_t size) { _store_wbuf *b = calloc(1, sizeof(_store_wbuf)); if (b == NULL) return NULL; b->buf = calloc(size, sizeof(char)); if (b->buf == NULL) { free(b); return NULL; } b->buf_pos = b->buf; b->free = size; b->size = size; return b; } static store_io_thread *_get_io_thread(store_engine *e) { int tid = -1; long long int low = LLONG_MAX; pthread_mutex_lock(&e->mutex); // find smallest queue. ignoring lock since being wrong isn't fatal. // TODO: if average queue depth can be quickly tracked, can break as soon // as we see a thread that's less than average, and start from last_io_thread for (int x = 0; x < e->io_threadcount; x++) { if (e->io_threads[x].depth == 0) { tid = x; break; } else if (e->io_threads[x].depth < low) { tid = x; low = e->io_threads[x].depth; } } pthread_mutex_unlock(&e->mutex); return &e->io_threads[tid]; } static uint64_t _next_version(store_engine *e) { return e->version++; } static void *extstore_io_thread(void *arg); static void *extstore_maint_thread(void *arg); /* Copies stats internal to engine and computes any derived values */ void extstore_get_stats(void *ptr, struct extstore_stats *st) { store_engine *e = (store_engine *)ptr; STAT_L(e); memcpy(st, &e->stats, sizeof(struct extstore_stats)); STAT_UL(e); // grab pages_free/pages_used pthread_mutex_lock(&e->mutex); st->pages_free = e->page_free; st->pages_used = e->page_count - e->page_free; pthread_mutex_unlock(&e->mutex); st->io_queue = 0; for (int x = 0; x < e->io_threadcount; x++) { pthread_mutex_lock(&e->io_threads[x].mutex); st->io_queue += e->io_threads[x].depth; pthread_mutex_unlock(&e->io_threads[x].mutex); } // calculate bytes_fragmented. // note that open and yet-filled pages count against fragmentation. st->bytes_fragmented = st->pages_used * e->page_size - st->bytes_used; } void extstore_get_page_data(void *ptr, struct extstore_stats *st) { store_engine *e = (store_engine *)ptr; STAT_L(e); memcpy(st->page_data, e->stats.page_data, sizeof(struct extstore_page_data) * e->page_count); STAT_UL(e); } const char *extstore_err(enum extstore_res res) { const char *rv = "unknown error"; switch (res) { case EXTSTORE_INIT_BAD_WBUF_SIZE: rv = "page_size must be divisible by wbuf_size"; break; case EXTSTORE_INIT_NEED_MORE_WBUF: rv = "wbuf_count must be >= page_buckets"; break; case EXTSTORE_INIT_NEED_MORE_BUCKETS: rv = "page_buckets must be > 0"; break; case EXTSTORE_INIT_PAGE_WBUF_ALIGNMENT: rv = "page_size and wbuf_size must be divisible by 1024*1024*2"; break; case EXTSTORE_INIT_TOO_MANY_PAGES: rv = "page_count must total to < 65536. Increase page_size or lower path sizes"; break; case EXTSTORE_INIT_OOM: rv = "failed calloc for engine"; break; case EXTSTORE_INIT_OPEN_FAIL: rv = "failed to open file"; break; case EXTSTORE_INIT_THREAD_FAIL: break; } return rv; } // TODO: #define's for DEFAULT_BUCKET, FREE_VERSION, etc void *extstore_init(struct extstore_conf_file *fh, struct extstore_conf *cf, enum extstore_res *res) { int i; struct extstore_conf_file *f = NULL; pthread_t thread; if (cf->page_size % cf->wbuf_size != 0) { *res = EXTSTORE_INIT_BAD_WBUF_SIZE; return NULL; } // Should ensure at least one write buffer per potential page if (cf->page_buckets > cf->wbuf_count) { *res = EXTSTORE_INIT_NEED_MORE_WBUF; return NULL; } if (cf->page_buckets < 1) { *res = EXTSTORE_INIT_NEED_MORE_BUCKETS; return NULL; } // TODO: More intelligence around alignment of flash erasure block sizes if (cf->page_size % (1024 * 1024 * 2) != 0 || cf->wbuf_size % (1024 * 1024 * 2) != 0) { *res = EXTSTORE_INIT_PAGE_WBUF_ALIGNMENT; return NULL; } store_engine *e = calloc(1, sizeof(store_engine)); if (e == NULL) { *res = EXTSTORE_INIT_OOM; return NULL; } e->page_size = cf->page_size; uint64_t temp_page_count = 0; for (f = fh; f != NULL; f = f->next) { f->fd = open(f->file, O_RDWR | O_CREAT, 0644); if (f->fd < 0) { *res = EXTSTORE_INIT_OPEN_FAIL; #ifdef EXTSTORE_DEBUG perror("extstore open"); #endif free(e); return NULL; } // use an fcntl lock to help avoid double starting. struct flock lock; lock.l_type = F_WRLCK; lock.l_start = 0; lock.l_whence = SEEK_SET; lock.l_len = 0; if (fcntl(f->fd, F_SETLK, &lock) < 0) { *res = EXTSTORE_INIT_OPEN_FAIL; free(e); return NULL; } if (ftruncate(f->fd, 0) < 0) { *res = EXTSTORE_INIT_OPEN_FAIL; free(e); return NULL; } temp_page_count += f->page_count; f->offset = 0; } if (temp_page_count >= UINT16_MAX) { *res = EXTSTORE_INIT_TOO_MANY_PAGES; free(e); return NULL; } e->page_count = temp_page_count; e->pages = calloc(e->page_count, sizeof(store_page)); if (e->pages == NULL) { *res = EXTSTORE_INIT_OOM; // FIXME: loop-close. make error label free(e); return NULL; } // interleave the pages between devices f = NULL; // start at the first device. for (i = 0; i < e->page_count; i++) { // find next device with available pages while (1) { // restart the loop if (f == NULL || f->next == NULL) { f = fh; } else { f = f->next; } if (f->page_count) { f->page_count--; break; } } pthread_mutex_init(&e->pages[i].mutex, NULL); e->pages[i].id = i; e->pages[i].fd = f->fd; e->pages[i].free_bucket = f->free_bucket; e->pages[i].offset = f->offset; e->pages[i].free = true; f->offset += e->page_size; } // free page buckets allows the app to organize devices by use case e->free_page_buckets = calloc(cf->page_buckets, sizeof(store_page *)); e->page_bucketcount = cf->page_buckets; for (i = e->page_count-1; i > 0; i--) { e->page_free++; if (e->pages[i].free_bucket == 0) { e->pages[i].next = e->page_freelist; e->page_freelist = &e->pages[i]; } else { int fb = e->pages[i].free_bucket; e->pages[i].next = e->free_page_buckets[fb]; e->free_page_buckets[fb] = &e->pages[i]; } } // 0 is magic "page is freed" version e->version = 1; // scratch data for stats. TODO: malloc failure handle e->stats.page_data = calloc(e->page_count, sizeof(struct extstore_page_data)); e->stats.page_count = e->page_count; e->stats.page_size = e->page_size; // page buckets lazily have pages assigned into them e->page_buckets = calloc(cf->page_buckets, sizeof(store_page *)); e->page_bucketcount = cf->page_buckets; // allocate write buffers // also IO's to use for shipping to IO thread for (i = 0; i < cf->wbuf_count; i++) { _store_wbuf *w = wbuf_new(cf->wbuf_size); obj_io *io = calloc(1, sizeof(obj_io)); /* TODO: on error, loop again and free stack. */ w->next = e->wbuf_stack; e->wbuf_stack = w; io->next = e->io_stack; e->io_stack = io; } pthread_mutex_init(&e->mutex, NULL); pthread_mutex_init(&e->stats_mutex, NULL); e->io_depth = cf->io_depth; // spawn threads e->io_threads = calloc(cf->io_threadcount, sizeof(store_io_thread)); for (i = 0; i < cf->io_threadcount; i++) { pthread_mutex_init(&e->io_threads[i].mutex, NULL); pthread_cond_init(&e->io_threads[i].cond, NULL); e->io_threads[i].e = e; // FIXME: error handling pthread_create(&thread, NULL, extstore_io_thread, &e->io_threads[i]); thread_setname(thread, "mc-ext-io"); } e->io_threadcount = cf->io_threadcount; e->maint_thread = calloc(1, sizeof(store_maint_thread)); e->maint_thread->e = e; // FIXME: error handling pthread_mutex_init(&e->maint_thread->mutex, NULL); pthread_cond_init(&e->maint_thread->cond, NULL); pthread_create(&thread, NULL, extstore_maint_thread, e->maint_thread); thread_setname(thread, "mc-ext-maint"); extstore_run_maint(e); return (void *)e; } void extstore_run_maint(void *ptr) { store_engine *e = (store_engine *)ptr; pthread_cond_signal(&e->maint_thread->cond); } // call with *e locked static store_page *_allocate_page(store_engine *e, unsigned int bucket, unsigned int free_bucket) { assert(!e->page_buckets[bucket] || e->page_buckets[bucket]->allocated == e->page_size); store_page *tmp = NULL; // if a specific free bucket was requested, check there first if (free_bucket != 0 && e->free_page_buckets[free_bucket] != NULL) { assert(e->page_free > 0); tmp = e->free_page_buckets[free_bucket]; e->free_page_buckets[free_bucket] = tmp->next; } // failing that, try the global list. if (tmp == NULL && e->page_freelist != NULL) { tmp = e->page_freelist; e->page_freelist = tmp->next; } E_DEBUG("EXTSTORE: allocating new page\n"); // page_freelist can be empty if the only free pages are specialized and // we didn't just request one. if (e->page_free > 0 && tmp != NULL) { tmp->next = e->page_buckets[bucket]; e->page_buckets[bucket] = tmp; tmp->active = true; tmp->free = false; tmp->closed = false; tmp->version = _next_version(e); tmp->bucket = bucket; e->page_free--; STAT_INCR(e, page_allocs, 1); } else { extstore_run_maint(e); } if (tmp) E_DEBUG("EXTSTORE: got page %u\n", tmp->id); return tmp; } // call with *p locked. locks *e static void _allocate_wbuf(store_engine *e, store_page *p) { _store_wbuf *wbuf = NULL; assert(!p->wbuf); pthread_mutex_lock(&e->mutex); if (e->wbuf_stack) { wbuf = e->wbuf_stack; e->wbuf_stack = wbuf->next; wbuf->next = 0; } pthread_mutex_unlock(&e->mutex); if (wbuf) { wbuf->offset = p->allocated; p->allocated += wbuf->size; wbuf->free = wbuf->size; wbuf->buf_pos = wbuf->buf; wbuf->full = false; wbuf->flushed = false; p->wbuf = wbuf; } } /* callback after wbuf is flushed. can only remove wbuf's from the head onward * if successfully flushed, which complicates this routine. each callback * attempts to free the wbuf stack, which is finally done when the head wbuf's * callback happens. * It's rare flushes would happen out of order. */ static void _wbuf_cb(void *ep, obj_io *io, int ret) { store_engine *e = (store_engine *)ep; store_page *p = &e->pages[io->page_id]; _store_wbuf *w = (_store_wbuf *) io->data; // TODO: Examine return code. Not entirely sure how to handle errors. // Naive first-pass should probably cause the page to close/free. w->flushed = true; pthread_mutex_lock(&p->mutex); assert(p->wbuf != NULL && p->wbuf == w); assert(p->written == w->offset); p->written += w->size; p->wbuf = NULL; if (p->written == e->page_size) p->active = false; // return the wbuf pthread_mutex_lock(&e->mutex); w->next = e->wbuf_stack; e->wbuf_stack = w; // also return the IO we just used. io->next = e->io_stack; e->io_stack = io; pthread_mutex_unlock(&e->mutex); pthread_mutex_unlock(&p->mutex); } /* Wraps pages current wbuf in an io and submits to IO thread. * Called with p locked, locks e. */ static void _submit_wbuf(store_engine *e, store_page *p) { _store_wbuf *w; pthread_mutex_lock(&e->mutex); obj_io *io = e->io_stack; e->io_stack = io->next; pthread_mutex_unlock(&e->mutex); w = p->wbuf; // zero out the end of the wbuf to allow blind readback of data. memset(w->buf + (w->size - w->free), 0, w->free); io->next = NULL; io->mode = OBJ_IO_WRITE; io->page_id = p->id; io->data = w; io->offset = w->offset; io->len = w->size; io->buf = w->buf; io->cb = _wbuf_cb; extstore_submit(e, io); } /* engine write function; takes engine, item_io. * fast fail if no available write buffer (flushing) * lock engine context, find active page, unlock * if page full, submit page/buffer to io thread. * * write is designed to be flaky; if page full, caller must try again to get * new page. best if used from a background thread that can harmlessly retry. */ int extstore_write_request(void *ptr, unsigned int bucket, unsigned int free_bucket, obj_io *io) { store_engine *e = (store_engine *)ptr; store_page *p; int ret = -1; if (bucket >= e->page_bucketcount) return ret; pthread_mutex_lock(&e->mutex); p = e->page_buckets[bucket]; if (!p) { p = _allocate_page(e, bucket, free_bucket); } pthread_mutex_unlock(&e->mutex); if (!p) return ret; pthread_mutex_lock(&p->mutex); // FIXME: can't null out page_buckets!!! // page is full, clear bucket and retry later. if (!p->active || ((!p->wbuf || p->wbuf->full) && p->allocated >= e->page_size)) { pthread_mutex_unlock(&p->mutex); pthread_mutex_lock(&e->mutex); _allocate_page(e, bucket, free_bucket); pthread_mutex_unlock(&e->mutex); return ret; } // if io won't fit, submit IO for wbuf and find new one. if (p->wbuf && p->wbuf->free < io->len && !p->wbuf->full) { _submit_wbuf(e, p); p->wbuf->full = true; } if (!p->wbuf && p->allocated < e->page_size) { _allocate_wbuf(e, p); } // hand over buffer for caller to copy into // leaves p locked. if (p->wbuf && !p->wbuf->full && p->wbuf->free >= io->len) { io->buf = p->wbuf->buf_pos; io->page_id = p->id; return 0; } pthread_mutex_unlock(&p->mutex); // p->written is incremented post-wbuf flush return ret; } /* _must_ be called after a successful write_request. * fills the rest of io structure. */ void extstore_write(void *ptr, obj_io *io) { store_engine *e = (store_engine *)ptr; store_page *p = &e->pages[io->page_id]; io->offset = p->wbuf->offset + (p->wbuf->size - p->wbuf->free); io->page_version = p->version; p->wbuf->buf_pos += io->len; p->wbuf->free -= io->len; p->bytes_used += io->len; p->obj_count++; STAT_L(e); e->stats.bytes_written += io->len; e->stats.bytes_used += io->len; e->stats.objects_written++; e->stats.objects_used++; STAT_UL(e); pthread_mutex_unlock(&p->mutex); } /* engine submit function; takes engine, item_io stack. * lock io_thread context and add stack? * signal io thread to wake. * return success. */ int extstore_submit(void *ptr, obj_io *io) { store_engine *e = (store_engine *)ptr; unsigned int depth = 0; obj_io *tio = io; obj_io *tail = NULL; while (tio != NULL) { tail = tio; // keep updating potential tail. depth++; tio = tio->next; } store_io_thread *t = _get_io_thread(e); pthread_mutex_lock(&t->mutex); t->depth += depth; if (t->queue == NULL) { t->queue = io; t->queue_tail = tail; } else { // Have to put the *io stack at the end of current queue. assert(tail->next == NULL); assert(t->queue_tail->next == NULL); t->queue_tail->next = io; t->queue_tail = tail; } pthread_mutex_unlock(&t->mutex); //pthread_mutex_lock(&t->mutex); pthread_cond_signal(&t->cond); //pthread_mutex_unlock(&t->mutex); return 0; } /* engine note delete function: takes engine, page id, size? * note that an item in this page is no longer valid */ int extstore_delete(void *ptr, unsigned int page_id, uint64_t page_version, unsigned int count, unsigned int bytes) { store_engine *e = (store_engine *)ptr; // FIXME: validate page_id in bounds store_page *p = &e->pages[page_id]; int ret = 0; pthread_mutex_lock(&p->mutex); if (!p->closed && p->version == page_version) { if (p->bytes_used >= bytes) { p->bytes_used -= bytes; } else { p->bytes_used = 0; } if (p->obj_count >= count) { p->obj_count -= count; } else { p->obj_count = 0; // caller has bad accounting? } STAT_L(e); e->stats.bytes_used -= bytes; e->stats.objects_used -= count; STAT_UL(e); if (p->obj_count == 0) { extstore_run_maint(e); } } else { ret = -1; } pthread_mutex_unlock(&p->mutex); return ret; } int extstore_check(void *ptr, unsigned int page_id, uint64_t page_version) { store_engine *e = (store_engine *)ptr; store_page *p = &e->pages[page_id]; int ret = 0; pthread_mutex_lock(&p->mutex); if (p->version != page_version) ret = -1; pthread_mutex_unlock(&p->mutex); return ret; } /* allows a compactor to say "we're done with this page, kill it. */ void extstore_close_page(void *ptr, unsigned int page_id, uint64_t page_version) { store_engine *e = (store_engine *)ptr; store_page *p = &e->pages[page_id]; pthread_mutex_lock(&p->mutex); if (!p->closed && p->version == page_version) { p->closed = true; extstore_run_maint(e); } pthread_mutex_unlock(&p->mutex); } /* Finds an attached wbuf that can satisfy the read. * Since wbufs can potentially be flushed to disk out of order, they are only * removed as the head of the list successfully flushes to disk. */ // call with *p locked // FIXME: protect from reading past wbuf static inline int _read_from_wbuf(store_page *p, obj_io *io) { _store_wbuf *wbuf = p->wbuf; assert(wbuf != NULL); assert(io->offset < p->written + wbuf->size); if (io->iov == NULL) { memcpy(io->buf, wbuf->buf + (io->offset - wbuf->offset), io->len); } else { int x; unsigned int off = io->offset - wbuf->offset; // need to loop fill iovecs for (x = 0; x < io->iovcnt; x++) { struct iovec *iov = &io->iov[x]; memcpy(iov->iov_base, wbuf->buf + off, iov->iov_len); off += iov->iov_len; } } return io->len; } /* engine IO thread; takes engine context * manage writes/reads * runs IO callbacks inline after each IO */ // FIXME: protect from reading past page static void *extstore_io_thread(void *arg) { store_io_thread *me = (store_io_thread *)arg; store_engine *e = me->e; while (1) { obj_io *io_stack = NULL; pthread_mutex_lock(&me->mutex); if (me->queue == NULL) { pthread_cond_wait(&me->cond, &me->mutex); } // Pull and disconnect a batch from the queue // Chew small batches from the queue so the IO thread picker can keep // the IO queue depth even, instead of piling on threads one at a time // as they gobble a queue. if (me->queue != NULL) { int i; obj_io *end = NULL; io_stack = me->queue; end = io_stack; for (i = 1; i < e->io_depth; i++) { if (end->next) { end = end->next; } else { me->queue_tail = end->next; break; } } me->depth -= i; me->queue = end->next; end->next = NULL; } pthread_mutex_unlock(&me->mutex); obj_io *cur_io = io_stack; while (cur_io) { // We need to note next before the callback in case the obj_io // gets reused. obj_io *next = cur_io->next; int ret = 0; int do_op = 1; store_page *p = &e->pages[cur_io->page_id]; // TODO: loop if not enough bytes were read/written. switch (cur_io->mode) { case OBJ_IO_READ: // Page is currently open. deal if read is past the end. pthread_mutex_lock(&p->mutex); if (!p->free && !p->closed && p->version == cur_io->page_version) { if (p->active && cur_io->offset >= p->written) { ret = _read_from_wbuf(p, cur_io); do_op = 0; } else { p->refcount++; } STAT_L(e); e->stats.bytes_read += cur_io->len; e->stats.objects_read++; STAT_UL(e); } else { do_op = 0; ret = -2; // TODO: enum in IO for status? } pthread_mutex_unlock(&p->mutex); if (do_op) { #if !defined(HAVE_PREAD) || !defined(HAVE_PREADV) // TODO: lseek offset is natively 64-bit on OS X, but // perhaps not on all platforms? Else use lseek64() ret = lseek(p->fd, p->offset + cur_io->offset, SEEK_SET); if (ret >= 0) { if (cur_io->iov == NULL) { ret = read(p->fd, cur_io->buf, cur_io->len); } else { ret = readv(p->fd, cur_io->iov, cur_io->iovcnt); } } #else if (cur_io->iov == NULL) { ret = pread(p->fd, cur_io->buf, cur_io->len, p->offset + cur_io->offset); } else { ret = preadv(p->fd, cur_io->iov, cur_io->iovcnt, p->offset + cur_io->offset); } #endif } break; case OBJ_IO_WRITE: do_op = 0; // FIXME: Should hold refcount during write. doesn't // currently matter since page can't free while active. ret = pwrite(p->fd, cur_io->buf, cur_io->len, p->offset + cur_io->offset); break; } if (ret == 0) { E_DEBUG("read returned nothing\n"); } #ifdef EXTSTORE_DEBUG if (ret == -1) { perror("read/write op failed"); } #endif cur_io->cb(e, cur_io, ret); if (do_op) { pthread_mutex_lock(&p->mutex); p->refcount--; pthread_mutex_unlock(&p->mutex); } cur_io = next; } } return NULL; } // call with *p locked. static void _free_page(store_engine *e, store_page *p) { store_page *tmp = NULL; store_page *prev = NULL; E_DEBUG("EXTSTORE: freeing page %u\n", p->id); STAT_L(e); e->stats.objects_used -= p->obj_count; e->stats.bytes_used -= p->bytes_used; e->stats.page_reclaims++; STAT_UL(e); pthread_mutex_lock(&e->mutex); // unlink page from bucket list tmp = e->page_buckets[p->bucket]; while (tmp) { if (tmp == p) { if (prev) { prev->next = tmp->next; } else { e->page_buckets[p->bucket] = tmp->next; } tmp->next = NULL; break; } prev = tmp; tmp = tmp->next; } // reset most values p->version = 0; p->obj_count = 0; p->bytes_used = 0; p->allocated = 0; p->written = 0; p->bucket = 0; p->active = false; p->closed = false; p->free = true; // add to page stack // TODO: free_page_buckets first class and remove redundancy? if (p->free_bucket != 0) { p->next = e->free_page_buckets[p->free_bucket]; e->free_page_buckets[p->free_bucket] = p; } else { p->next = e->page_freelist; e->page_freelist = p; } e->page_free++; pthread_mutex_unlock(&e->mutex); } /* engine maint thread; takes engine context. * Uses version to ensure oldest possible objects are being evicted. * Needs interface to inform owner of pages with fewer objects or most space * free, which can then be actively compacted to avoid eviction. * * This gets called asynchronously after every page allocation. Could run less * often if more pages are free. * * Another allocation call is required if an attempted free didn't happen * due to the page having a refcount. */ // TODO: Don't over-evict pages if waiting on refcounts to drop static void *extstore_maint_thread(void *arg) { store_maint_thread *me = (store_maint_thread *)arg; store_engine *e = me->e; struct extstore_page_data *pd = calloc(e->page_count, sizeof(struct extstore_page_data)); pthread_mutex_lock(&me->mutex); while (1) { int i; bool do_evict = false; unsigned int low_page = 0; uint64_t low_version = ULLONG_MAX; pthread_cond_wait(&me->cond, &me->mutex); pthread_mutex_lock(&e->mutex); // default freelist requires at least one page free. // specialized freelists fall back to default once full. if (e->page_free == 0 || e->page_freelist == NULL) { do_evict = true; } pthread_mutex_unlock(&e->mutex); memset(pd, 0, sizeof(struct extstore_page_data) * e->page_count); for (i = 0; i < e->page_count; i++) { store_page *p = &e->pages[i]; pthread_mutex_lock(&p->mutex); pd[p->id].free_bucket = p->free_bucket; if (p->active || p->free) { pthread_mutex_unlock(&p->mutex); continue; } if (p->obj_count > 0 && !p->closed) { pd[p->id].version = p->version; pd[p->id].bytes_used = p->bytes_used; pd[p->id].bucket = p->bucket; // low_version/low_page are only used in the eviction // scenario. when we evict, it's only to fill the default page // bucket again. // TODO: experiment with allowing evicting up to a single page // for any specific free bucket. this is *probably* required // since it could cause a load bias on default-only devices? if (p->free_bucket == 0 && p->version < low_version) { low_version = p->version; low_page = i; } } if ((p->obj_count == 0 || p->closed) && p->refcount == 0) { _free_page(e, p); // Found a page to free, no longer need to evict. do_evict = false; } pthread_mutex_unlock(&p->mutex); } if (do_evict && low_version != ULLONG_MAX) { store_page *p = &e->pages[low_page]; E_DEBUG("EXTSTORE: evicting page [%d] [v: %llu]\n", p->id, (unsigned long long) p->version); pthread_mutex_lock(&p->mutex); if (!p->closed) { p->closed = true; STAT_L(e); e->stats.page_evictions++; e->stats.objects_evicted += p->obj_count; e->stats.bytes_evicted += p->bytes_used; STAT_UL(e); if (p->refcount == 0) { _free_page(e, p); } } pthread_mutex_unlock(&p->mutex); } // copy the page data into engine context so callers can use it from // the stats lock. STAT_L(e); memcpy(e->stats.page_data, pd, sizeof(struct extstore_page_data) * e->page_count); STAT_UL(e); } return NULL; } memcached-1.6.20/bipbuffer.h0000664000175000017500000000410613704126374012556 00000000000000#ifndef BIPBUFFER_H #define BIPBUFFER_H typedef struct { unsigned long int size; /* region A */ unsigned int a_start, a_end; /* region B */ unsigned int b_end; /* is B inuse? */ int b_inuse; unsigned char data[]; } bipbuf_t; /** * Create a new bip buffer. * * malloc()s space * * @param[in] size The size of the buffer */ bipbuf_t *bipbuf_new(const unsigned int size); /** * Initialise a bip buffer. Use memory provided by user. * * No malloc()s are performed. * * @param[in] size The size of the array */ void bipbuf_init(bipbuf_t* me, const unsigned int size); /** * Free the bip buffer */ void bipbuf_free(bipbuf_t *me); /* TODO: DOCUMENTATION */ unsigned char *bipbuf_request(bipbuf_t* me, const int size); int bipbuf_push(bipbuf_t* me, const int size); /** * @param[in] data The data to be offered to the buffer * @param[in] size The size of the data to be offered * @return number of bytes offered */ int bipbuf_offer(bipbuf_t *me, const unsigned char *data, const int size); /** * Look at data. Don't move cursor * * @param[in] len The length of the data to be peeked * @return data on success, NULL if we can't peek at this much data */ unsigned char *bipbuf_peek(const bipbuf_t* me, const unsigned int len); /** * Look at data. Don't move cursor * * @param[in] len The length of the data returned * @return data on success, NULL if nothing available */ unsigned char *bipbuf_peek_all(const bipbuf_t* me, unsigned int *len); /** * Get pointer to data to read. Move the cursor on. * * @param[in] len The length of the data to be polled * @return pointer to data, NULL if we can't poll this much data */ unsigned char *bipbuf_poll(bipbuf_t* me, const unsigned int size); /** * @return the size of the bipbuffer */ int bipbuf_size(const bipbuf_t* me); /** * @return 1 if buffer is empty; 0 otherwise */ int bipbuf_is_empty(const bipbuf_t* me); /** * @return how much space we have assigned */ int bipbuf_used(const bipbuf_t* cb); /** * @return bytes of unused space */ int bipbuf_unused(const bipbuf_t* me); #endif /* BIPBUFFER_H */ memcached-1.6.20/proxy_jump_hash.c0000664000175000017500000000262314340006077014020 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "proxy.h" typedef struct { struct proxy_hash_caller phc; // passed back to proxy API unsigned int buckets; } mcplib_jump_hash_t; static uint32_t mcplib_dist_jump_hash_get_server(uint64_t hash, void *ctx) { mcplib_jump_hash_t *jh = ctx; int64_t b = -1, j = 0; while (j < jh->buckets) { b = j; hash = hash * 2862933555777941757ULL + 1; j = (b + 1) * ((double)(1LL << 31) / (double)((hash >> 33) + 1)); } return b; } // stack = [pool, option] static int mcplib_dist_jump_hash_new(lua_State *L) { luaL_checktype(L, 1, LUA_TTABLE); lua_Unsigned buckets = lua_rawlen(L, 1); mcplib_jump_hash_t *jh = lua_newuserdatauv(L, sizeof(mcplib_jump_hash_t), 0); // don't need to loop through the table at all, just need its length. // could optimize startup time by adding hints to the module for how to // format pool (ie; just a total count or the full table) jh->buckets = buckets; jh->phc.ctx = jh; jh->phc.selector_func = mcplib_dist_jump_hash_get_server; lua_pushlightuserdata(L, &jh->phc); // - return [UD, lightuserdata] return 2; } int mcplib_open_dist_jump_hash(lua_State *L) { const struct luaL_Reg jump_f[] = { {"new", mcplib_dist_jump_hash_new}, {NULL, NULL}, }; luaL_newlib(L, jump_f); return 1; } memcached-1.6.20/proxy.h0000664000175000017500000004665114427543277012016 00000000000000#ifndef PROXY_H #define PROXY_H #include "memcached.h" #include "extstore.h" #include #include #include #include #include #include #include #include "config.h" #if defined(__linux__) #define USE_EVENTFD 1 #include #endif #ifdef HAVE_LIBURING #include #include // POLLOUT for liburing. #define PRING_QUEUE_SQ_ENTRIES 2048 #define PRING_QUEUE_CQ_ENTRIES 16384 #endif #include "proto_proxy.h" #include "proto_text.h" #include "queue.h" #define XXH_INLINE_ALL // modifier for xxh3's include below #include "xxhash.h" #ifdef PROXY_DEBUG #define P_DEBUG(...) \ do { \ fprintf(stderr, __VA_ARGS__); \ } while (0) #else #define P_DEBUG(...) #endif #define WSTAT_L(t) pthread_mutex_lock(&t->stats.mutex); #define WSTAT_UL(t) pthread_mutex_unlock(&t->stats.mutex); #define WSTAT_INCR(t, stat, amount) { \ pthread_mutex_lock(&t->stats.mutex); \ t->stats.stat += amount; \ pthread_mutex_unlock(&t->stats.mutex); \ } #define WSTAT_DECR(t, stat, amount) { \ pthread_mutex_lock(&t->stats.mutex); \ t->stats.stat -= amount; \ pthread_mutex_unlock(&t->stats.mutex); \ } #define STAT_L(ctx) pthread_mutex_lock(&ctx->stats_lock); #define STAT_UL(ctx) pthread_mutex_unlock(&ctx->stats_lock); #define STAT_INCR(ctx, stat, amount) { \ pthread_mutex_lock(&ctx->stats_lock); \ ctx->global_stats.stat += amount; \ pthread_mutex_unlock(&ctx->stats_lock); \ } #define STAT_DECR(ctx, stat, amount) { \ pthread_mutex_lock(&ctx->stats_lock); \ ctx->global_stats.stat -= amount; \ pthread_mutex_unlock(&ctx->stats_lock); \ } // FIXME (v2): do include dir properly. #include "vendor/mcmc/mcmc.h" // Note: value created from thin air. Could be shorter. #define MCP_REQUEST_MAXLEN KEY_MAX_LENGTH * 2 #define ENDSTR "END\r\n" #define ENDLEN sizeof(ENDSTR)-1 #define MCP_BACKEND_UPVALUE 1 #define MCP_YIELD_POOL 1 #define MCP_YIELD_AWAIT 2 #define MCP_YIELD_LOCAL 3 // all possible commands. #define CMD_FIELDS \ X(CMD_MG) \ X(CMD_MS) \ X(CMD_MD) \ X(CMD_MN) \ X(CMD_MA) \ X(CMD_ME) \ X(CMD_GET) \ X(CMD_GAT) \ X(CMD_SET) \ X(CMD_ADD) \ X(CMD_CAS) \ X(CMD_GETS) \ X(CMD_GATS) \ X(CMD_INCR) \ X(CMD_DECR) \ X(CMD_TOUCH) \ X(CMD_APPEND) \ X(CMD_DELETE) \ X(CMD_REPLACE) \ X(CMD_PREPEND) \ X(CMD_END_STORAGE) \ X(CMD_QUIT) \ X(CMD_STATS) \ X(CMD_SLABS) \ X(CMD_WATCH) \ X(CMD_LRU) \ X(CMD_VERSION) \ X(CMD_SHUTDOWN) \ X(CMD_EXTSTORE) \ X(CMD_FLUSH_ALL) \ X(CMD_VERBOSITY) \ X(CMD_LRU_CRAWLER) \ X(CMD_REFRESH_CERTS) \ X(CMD_CACHE_MEMLIMIT) #define X(name) name, enum proxy_defines { P_OK = 0, CMD_FIELDS CMD_SIZE, // used to define array size for command hooks. CMD_ANY, // override _all_ commands CMD_ANY_STORAGE, // override commands specific to key storage. CMD_FINAL, // end cap for convenience. }; #undef X // certain classes of ascii commands have similar parsing (ie; // get/gets/gat/gats). Use types so we don't have to test a ton of them. enum proxy_cmd_types { CMD_TYPE_GENERIC = 0, CMD_TYPE_GET, // get/gets/gat/gats CMD_TYPE_META, // m*'s. }; typedef struct _io_pending_proxy_t io_pending_proxy_t; typedef struct proxy_event_thread_s proxy_event_thread_t; #ifdef HAVE_LIBURING // TODO: pass in cqe->res instead of cqe? typedef void (*proxy_event_cb)(void *udata, struct io_uring_cqe *cqe); typedef struct { void *udata; proxy_event_cb cb; bool set; // NOTE: not sure if necessary if code structured properly } proxy_event_t; void *proxy_event_thread_ur(void *arg); #endif // Note: This ends up wasting a few counters, but simplifies the rest of the // process for handling internal worker stats. struct proxy_int_stats { uint64_t counters[CMD_FINAL]; }; struct proxy_user_stats { size_t num_stats; // number of stats, for sizing various arrays char **names; // not needed for worker threads uint64_t *counters; // array of counters. }; struct proxy_global_stats { uint64_t config_reloads; uint64_t config_reload_fails; uint64_t backend_total; uint64_t backend_disconn; // backends with no connections uint64_t backend_requests; // reqs sent to backends uint64_t backend_responses; // responses received from backends uint64_t backend_errors; // errors from backends uint64_t backend_marked_bad; // backend set to autofail uint64_t backend_failed; // an error caused a backend reset }; struct proxy_tunables { struct timeval connect; struct timeval retry; // wait time before retrying a dead backend struct timeval read; #ifdef HAVE_LIBURING struct __kernel_timespec connect_ur; struct __kernel_timespec retry_ur; struct __kernel_timespec read_ur; #endif // HAVE_LIBURING int backend_failure_limit; bool tcp_keepalive; }; typedef STAILQ_HEAD(pool_head_s, mcp_pool_s) pool_head_t; typedef struct { lua_State *proxy_state; void *proxy_code; proxy_event_thread_t *proxy_io_thread; uint64_t active_req_limit; // max total in-flight requests uint64_t buffer_memory_limit; // max bytes for send/receive buffers. pthread_mutex_t config_lock; pthread_cond_t config_cond; pthread_t config_tid; pthread_mutex_t worker_lock; pthread_cond_t worker_cond; pthread_t manager_tid; // deallocation management thread pthread_mutex_t manager_lock; pthread_cond_t manager_cond; pool_head_t manager_head; // stack for pool deallocation. bool worker_done; // signal variable for the worker lock/cond system. bool worker_failed; // covered by worker_lock as well. bool use_uring; // use IO_URING for backend connections. bool loading; // bool indicating an active config load. struct proxy_global_stats global_stats; struct proxy_user_stats user_stats; struct proxy_tunables tunables; // NOTE: updates covered by stats_lock pthread_mutex_t stats_lock; // used for rare global counters } proxy_ctx_t; #define PROXY_GET_THR_CTX(L) ((*(LIBEVENT_THREAD **)lua_getextraspace(L))->proxy_ctx) #define PROXY_GET_THR(L) (*(LIBEVENT_THREAD **)lua_getextraspace(L)) // Operations from the config VM don't have a libevent thread. #define PROXY_GET_CTX(L) (*(proxy_ctx_t **)lua_getextraspace(L)) struct proxy_hook_tagged { uint64_t tag; int lua_ref; }; struct proxy_hook { int lua_ref; int tagcount; struct proxy_hook_tagged *tagged; // array of possible tagged hooks. }; // TODO (v2): some hash functions (crc?) might require initializers. If we run into // any the interface might need expanding. typedef uint64_t (*key_hash_func)(const void *key, size_t len, uint64_t seed); struct proxy_hash_func { key_hash_func func; }; typedef const char *(*key_hash_filter_func)(const char *conf, const char *key, size_t klen, size_t *newlen); typedef uint32_t (*hash_selector_func)(uint64_t hash, void *ctx); struct proxy_hash_caller { hash_selector_func selector_func; void *ctx; }; enum mcp_backend_states { mcp_backend_read = 0, // waiting to read any response mcp_backend_parse, // have some buffered data to check mcp_backend_read_end, // looking for an "END" marker for GET mcp_backend_want_read, // read more data to complete command mcp_backend_next, // advance to the next IO mcp_backend_next_close, // complete current request, then close socket }; typedef struct mcp_backend_wrap_s mcp_backend_wrap_t; typedef struct mcp_backend_label_s mcp_backend_label_t; typedef struct mcp_backend_s mcp_backend_t; typedef struct mcp_request_s mcp_request_t; typedef struct mcp_parser_s mcp_parser_t; #define PARSER_MAX_TOKENS 24 struct mcp_parser_meta_s { uint64_t flags; }; // Note that we must use offsets into request for tokens, // as *request can change between parsing and later accessors. struct mcp_parser_s { const char *request; void *vbuf; // temporary buffer for holding value lengths. uint8_t command; uint8_t cmd_type; // command class. uint8_t ntokens; uint8_t keytoken; // because GAT. sigh. also cmds without a key. uint32_t parsed; // how far into the request we parsed already uint32_t reqlen; // full length of request buffer. int vlen; uint32_t klen; // length of key. uint16_t tokens[PARSER_MAX_TOKENS]; // offsets for start of each token bool has_space; // a space was found after the last byte parsed. bool noreply; // if quiet/noreply mode is set. union { struct mcp_parser_meta_s meta; } t; }; #define MCP_PARSER_KEY(pr) (&pr.request[pr.tokens[pr.keytoken]]) #define MAX_REQ_TOKENS 2 struct mcp_request_s { mcp_parser_t pr; // non-lua-specific parser handling. mcp_backend_t *be; // backend handling this request. bool ascii_multiget; // ascii multiget mode. (hide errors/END) char request[]; }; typedef STAILQ_HEAD(io_head_s, _io_pending_proxy_t) io_head_t; #define MAX_LABELLEN 512 #define MAX_NAMELEN 255 #define MAX_PORTLEN 6 // TODO (v2): IOV_MAX tends to be 1000+ which would allow for more batching but we // don't have a good temporary space and don't want to malloc/free on every // write. transmit() uses the stack but we can't do that for uring's use case. #if (IOV_MAX > 1024) #define BE_IOV_MAX 1024 #else #define BE_IOV_MAX IOV_MAX #endif // lua descriptor object: passed to pools, which create wrappers. struct mcp_backend_label_s { char name[MAX_NAMELEN+1]; char port[MAX_PORTLEN+1]; char label[MAX_LABELLEN+1]; size_t llen; // cache label length for small speedup in pool creation. struct proxy_tunables tunables; }; // lua object wrapper meant to own a malloc'ed conn structure // when this object is created, it ships its connection to the real owner // (worker, IO thread, etc) // when this object is garbage collected, it ships a notice to the owner // thread to stop using and free the backend conn memory. struct mcp_backend_wrap_s { mcp_backend_t *be; }; // FIXME: inline the mcmc client data. // TODO: event_thread -> something? union of owner type? struct mcp_backend_s { int depth; // total number of requests in queue int pending_read; // number of requests written to socket, pending read. int failed_count; // number of fails (timeouts) in a row proxy_event_thread_t *event_thread; // event thread owning this backend. void *client; // mcmc client STAILQ_ENTRY(mcp_backend_s) be_next; // stack for backends STAILQ_ENTRY(mcp_backend_s) beconn_next; // stack for connecting conns io_head_t io_head; // stack of requests. io_pending_proxy_t *io_next; // next request to write. char *rbuf; // statically allocated read buffer. size_t rbufused; // currently active bytes in the buffer struct event main_event; // libevent: changes role, mostly for main read events struct event write_event; // libevent: only used when socket wbuf full struct event timeout_event; // libevent: alarm for pending reads struct proxy_tunables tunables; #ifdef HAVE_LIBURING proxy_event_t ur_rd_ev; // liburing. proxy_event_t ur_wr_ev; // need a separate event/cb for writing/polling proxy_event_t ur_te_ev; // for timeout handling #endif enum mcp_backend_states state; // readback state machine int connect_flags; // flags to pass to mcmc_connect bool transferred; // if beconn has been shipped to owner thread. bool connecting; // in the process of an asynch connection. bool validating; // in process of validating a new backend connection. bool can_write; // recently got a WANT_WRITE or are connecting. bool stacked; // if backend already queued for syscalls. bool bad; // timed out, marked as bad. bool use_io_thread; // note if this backend is worker-local or not. struct iovec write_iovs[BE_IOV_MAX]; // iovs to stage batched writes char name[MAX_NAMELEN+1]; char port[MAX_PORTLEN+1]; }; typedef STAILQ_HEAD(be_head_s, mcp_backend_s) be_head_t; typedef STAILQ_HEAD(beconn_head_s, mcp_backend_s) beconn_head_t; struct proxy_event_thread_s { pthread_t thread_id; struct event_base *base; struct event notify_event; // listen event for the notify pipe/eventfd. struct event beconn_event; // listener for backends in connect state #ifdef HAVE_LIBURING struct io_uring ring; proxy_event_t ur_notify_event; // listen on eventfd. proxy_event_t ur_benotify_event; // listen on eventfd for backend connections. eventfd_t event_counter; eventfd_t beevent_counter; bool use_uring; #endif pthread_mutex_t mutex; // covers stack. pthread_cond_t cond; // condition to wait on while stack drains. io_head_t io_head_in; // inbound requests to process. be_head_t be_head; // stack of backends for processing. beconn_head_t beconn_head_in; // stack of backends for connection processing. #ifdef USE_EVENTFD int event_fd; // for request ingestion int be_event_fd; // for backend ingestion #else int notify_receive_fd; int notify_send_fd; int be_notify_receive_fd; int be_notify_send_fd; #endif proxy_ctx_t *ctx; // main context. }; enum mcp_resp_mode { RESP_MODE_NORMAL = 0, RESP_MODE_NOREPLY, RESP_MODE_METAQUIET }; #define RESP_CMD_MAX 8 typedef struct { mcmc_resp_t resp; char *buf; // response line + potentially value. mc_resp *cresp; // client mc_resp object during extstore fetches. LIBEVENT_THREAD *thread; // cresp's owner thread needed for extstore cleanup. size_t blen; // total size of the value to read. struct timeval start; // time this object was created. long elapsed; // time elapsed once handled. int status; // status code from mcmc_read() int bread; // amount of bytes read into value so far. uint8_t cmd; // from parser (pr.command) enum mcp_resp_mode mode; // reply mode (for noreply fixing) char be_name[MAX_NAMELEN+1]; char be_port[MAX_PORTLEN+1]; } mcp_resp_t; // re-cast an io_pending_t into this more descriptive structure. // the first few items _must_ match the original struct. #define IO_PENDING_TYPE_PROXY 0 #define IO_PENDING_TYPE_EXTSTORE 1 struct _io_pending_proxy_t { int io_queue_type; LIBEVENT_THREAD *thread; conn *c; mc_resp *resp; io_queue_cb return_cb; // called on worker thread. io_queue_cb finalize_cb; // called back on the worker thread. // original struct ends here int io_type; // extstore IO or backend IO int coro_ref; // lua registry reference to the coroutine lua_State *coro; // pointer directly to the coroutine union { // extstore IO. struct { obj_io eio; item *hdr_it; mc_resp *tresp; // temporary mc_resp for storage to fill. int gettype; int iovec_data; bool miss; bool badcrc; bool active; }; // backend request IO struct { struct _io_pending_proxy_t *next; // stack for IO submission STAILQ_ENTRY(_io_pending_proxy_t) io_next; // stack for backends int mcpres_ref; // mcp.res reference used for await() mcp_backend_t *backend; // backend server to request from struct iovec iov[2]; // request string + tail buffer int iovcnt; // 1 or 2... unsigned int iovbytes; // total bytes in the iovec int await_ref; // lua reference if we were an await object mcp_resp_t *client_resp; // reference (currently pointing to a lua object) bool flushed; // whether we've fully written this request to a backend. bool ascii_multiget; // passed on from mcp_r_t bool is_await; // are we an await object? bool await_first; // are we the main route for an await object? bool await_background; // dummy IO for backgrounded awaits }; }; }; // Note: does *be have to be a sub-struct? how stable are userdata pointers? // https://stackoverflow.com/questions/38718475/lifetime-of-lua-userdata-pointers // - says no. typedef struct { int ref; // luaL_ref reference of backend_wrap_t obj. mcp_backend_t *be; } mcp_pool_be_t; #define KEY_HASH_FILTER_MAX 5 typedef struct mcp_pool_s mcp_pool_t; struct mcp_pool_s { struct proxy_hash_caller phc; key_hash_filter_func key_filter; key_hash_func key_hasher; pthread_mutex_t lock; // protects refcount. proxy_ctx_t *ctx; // main context. STAILQ_ENTRY(mcp_pool_s) next; // stack for deallocator. char key_filter_conf[KEY_HASH_FILTER_MAX+1]; char beprefix[MAX_LABELLEN+1]; // TODO: should probably be shorter. uint64_t hash_seed; // calculated from a string. int refcount; int phc_ref; int self_ref; // TODO (v2): double check that this is needed. int pool_size; bool use_iothread; mcp_pool_be_t pool[]; }; typedef struct { mcp_pool_t *main; // ptr to original mcp_pool_be_t *pool; // ptr to main->pool starting offset for owner thread. } mcp_pool_proxy_t; // utils bool proxy_bufmem_checkadd(LIBEVENT_THREAD *t, int len); // networking interface void proxy_init_event_thread(proxy_event_thread_t *t, proxy_ctx_t *ctx, struct event_base *base); void *proxy_event_thread(void *arg); void proxy_run_backend_queue(be_head_t *head); // await interface enum mcp_await_e { AWAIT_GOOD = 0, // looks for OK + NOT MISS AWAIT_ANY, // any response, including errors, AWAIT_OK, // any non-error response AWAIT_FIRST, // return the result from the first pool AWAIT_FASTGOOD, // returns on first hit or majority non-error AWAIT_BACKGROUND, // returns as soon as background jobs are dispatched }; int mcplib_await(lua_State *L); int mcplib_await_logerrors(lua_State *L); int mcplib_await_run(conn *c, mc_resp *resp, lua_State *L, int coro_ref); int mcplib_await_return(io_pending_proxy_t *p); // internal request interface int mcplib_internal(lua_State *L); int mcplib_internal_run(lua_State *L, conn *c, mc_resp *top_resp, int coro_ref); // user stats interface int mcplib_add_stat(lua_State *L); int mcplib_stat(lua_State *L); size_t _process_request_next_key(mcp_parser_t *pr); int process_request(mcp_parser_t *pr, const char *command, size_t cmdlen); mcp_request_t *mcp_new_request(lua_State *L, mcp_parser_t *pr, const char *command, size_t cmdlen); // request interface int mcplib_request(lua_State *L); int mcplib_request_command(lua_State *L); int mcplib_request_key(lua_State *L); int mcplib_request_ltrimkey(lua_State *L); int mcplib_request_rtrimkey(lua_State *L); int mcplib_request_token(lua_State *L); int mcplib_request_ntokens(lua_State *L); int mcplib_request_has_flag(lua_State *L); int mcplib_request_flag_token(lua_State *L); int mcplib_request_gc(lua_State *L); int mcplib_open_dist_jump_hash(lua_State *L); int mcplib_open_dist_ring_hash(lua_State *L); int proxy_run_coroutine(lua_State *Lc, mc_resp *resp, io_pending_proxy_t *p, conn *c); mcp_backend_t *mcplib_pool_proxy_call_helper(lua_State *L, mcp_pool_proxy_t *pp, const char *key, size_t len); void mcp_request_attach(lua_State *L, mcp_request_t *rq, io_pending_proxy_t *p); int mcp_request_render(mcp_request_t *rq, int idx, const char *tok, size_t len); void proxy_lua_error(lua_State *L, const char *s); void proxy_lua_ferror(lua_State *L, const char *fmt, ...); #define PROXY_SERVER_ERROR "SERVER_ERROR " #define PROXY_CLIENT_ERROR "CLIENT_ERROR " void proxy_out_errstring(mc_resp *resp, char *type, const char *str); int _start_proxy_config_threads(proxy_ctx_t *ctx); int proxy_thread_loadconf(proxy_ctx_t *ctx, LIBEVENT_THREAD *thr); // TODO (v2): more .h files, perhaps? int mcplib_open_hash_xxhash(lua_State *L); __attribute__((unused)) void dump_stack(lua_State *L); #endif memcached-1.6.20/sizes.c0000664000175000017500000000222714403667314011745 00000000000000#include #include "memcached.h" static void display(const char *name, size_t size) { printf("%s\t%d\n", name, (int)size); } int main(int argc, char **argv) { display("Slab Stats", sizeof(struct slab_stats)); display("Thread stats", sizeof(struct thread_stats) - (MAX_NUMBER_OF_SLAB_CLASSES * sizeof(struct slab_stats))); display("Global stats", sizeof(struct stats)); display("Settings", sizeof(struct settings)); display("Item (no cas)", sizeof(item)); display("Item (cas)", sizeof(item) + sizeof(uint64_t)); #ifdef EXTSTORE display("extstore header", sizeof(item_hdr)); #endif display("Libevent thread", sizeof(LIBEVENT_THREAD) - sizeof(struct thread_stats)); display("Connection", sizeof(conn)); display("Response object", sizeof(mc_resp)); display("Response bundle", sizeof(mc_resp_bundle)); display("Response objects per bundle", MAX_RESP_PER_BUNDLE); printf("----------------------------------------\n"); display("libevent thread cumulative", sizeof(LIBEVENT_THREAD)); display("Thread stats cumulative\t", sizeof(struct thread_stats)); return 0; } memcached-1.6.20/jenkins_hash.c0000664000175000017500000003456513704126374013265 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ /* * Hash table * * The hash function used here is by Bob Jenkins, 1996: * * "By Bob Jenkins, 1996. bob_jenkins@burtleburtle.net. * You may use this code any way you wish, private, educational, * or commercial. It's free." * */ #include "memcached.h" #include "jenkins_hash.h" /* * Since the hash function does bit manipulation, it needs to know * whether it's big or little-endian. ENDIAN_LITTLE and ENDIAN_BIG * are set in the configure script. */ #if ENDIAN_BIG == 1 # define HASH_LITTLE_ENDIAN 0 # define HASH_BIG_ENDIAN 1 #else # if ENDIAN_LITTLE == 1 # define HASH_LITTLE_ENDIAN 1 # define HASH_BIG_ENDIAN 0 # else # define HASH_LITTLE_ENDIAN 0 # define HASH_BIG_ENDIAN 0 # endif #endif #define rot(x,k) (((x)<<(k)) ^ ((x)>>(32-(k)))) /* ------------------------------------------------------------------------------- mix -- mix 3 32-bit values reversibly. This is reversible, so any information in (a,b,c) before mix() is still in (a,b,c) after mix(). If four pairs of (a,b,c) inputs are run through mix(), or through mix() in reverse, there are at least 32 bits of the output that are sometimes the same for one pair and different for another pair. This was tested for: * pairs that differed by one bit, by two bits, in any combination of top bits of (a,b,c), or in any combination of bottom bits of (a,b,c). * "differ" is defined as +, -, ^, or ~^. For + and -, I transformed the output delta to a Gray code (a^(a>>1)) so a string of 1's (as is commonly produced by subtraction) look like a single 1-bit difference. * the base values were pseudorandom, all zero but one bit set, or all zero plus a counter that starts at zero. Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that satisfy this are 4 6 8 16 19 4 9 15 3 18 27 15 14 9 3 7 17 3 Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing for "differ" defined as + with a one-bit base and a two-bit delta. I used http://burtleburtle.net/bob/hash/avalanche.html to choose the operations, constants, and arrangements of the variables. This does not achieve avalanche. There are input bits of (a,b,c) that fail to affect some output bits of (a,b,c), especially of a. The most thoroughly mixed value is c, but it doesn't really even achieve avalanche in c. This allows some parallelism. Read-after-writes are good at doubling the number of bits affected, so the goal of mixing pulls in the opposite direction as the goal of parallelism. I did what I could. Rotates seem to cost as much as shifts on every machine I could lay my hands on, and rotates are much kinder to the top and bottom bits, so I used rotates. ------------------------------------------------------------------------------- */ #define mix(a,b,c) \ { \ a -= c; a ^= rot(c, 4); c += b; \ b -= a; b ^= rot(a, 6); a += c; \ c -= b; c ^= rot(b, 8); b += a; \ a -= c; a ^= rot(c,16); c += b; \ b -= a; b ^= rot(a,19); a += c; \ c -= b; c ^= rot(b, 4); b += a; \ } /* ------------------------------------------------------------------------------- final -- final mixing of 3 32-bit values (a,b,c) into c Pairs of (a,b,c) values differing in only a few bits will usually produce values of c that look totally different. This was tested for * pairs that differed by one bit, by two bits, in any combination of top bits of (a,b,c), or in any combination of bottom bits of (a,b,c). * "differ" is defined as +, -, ^, or ~^. For + and -, I transformed the output delta to a Gray code (a^(a>>1)) so a string of 1's (as is commonly produced by subtraction) look like a single 1-bit difference. * the base values were pseudorandom, all zero but one bit set, or all zero plus a counter that starts at zero. These constants passed: 14 11 25 16 4 14 24 12 14 25 16 4 14 24 and these came close: 4 8 15 26 3 22 24 10 8 15 26 3 22 24 11 8 15 26 3 22 24 ------------------------------------------------------------------------------- */ #define final(a,b,c) \ { \ c ^= b; c -= rot(b,14); \ a ^= c; a -= rot(c,11); \ b ^= a; b -= rot(a,25); \ c ^= b; c -= rot(b,16); \ a ^= c; a -= rot(c,4); \ b ^= a; b -= rot(a,14); \ c ^= b; c -= rot(b,24); \ } #if HASH_LITTLE_ENDIAN == 1 uint32_t jenkins_hash( const void *key, /* the key to hash */ size_t length) /* length of the key */ { uint32_t a,b,c; /* internal state */ union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */ /* Set up the internal state */ a = b = c = 0xdeadbeef + ((uint32_t)length) + 0; u.ptr = key; if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) { const uint32_t *k = key; /* read 32-bit chunks */ #ifdef VALGRIND const uint8_t *k8; #endif /* ifdef VALGRIND */ /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */ while (length > 12) { a += k[0]; b += k[1]; c += k[2]; mix(a,b,c); length -= 12; k += 3; } /*----------------------------- handle the last (probably partial) block */ /* * "k[2]&0xffffff" actually reads beyond the end of the string, but * then masks off the part it's not allowed to read. Because the * string is aligned, the masked-off tail is in the same word as the * rest of the string. Every machine with memory protection I've seen * does it on word boundaries, so is OK with this. But VALGRIND will * still catch it and complain. The masking trick does make the hash * noticeably faster for short strings (like English words). */ #ifndef VALGRIND switch(length) { case 12: c+=k[2]; b+=k[1]; a+=k[0]; break; case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break; case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break; case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break; case 8 : b+=k[1]; a+=k[0]; break; case 7 : b+=k[1]&0xffffff; a+=k[0]; break; case 6 : b+=k[1]&0xffff; a+=k[0]; break; case 5 : b+=k[1]&0xff; a+=k[0]; break; case 4 : a+=k[0]; break; case 3 : a+=k[0]&0xffffff; break; case 2 : a+=k[0]&0xffff; break; case 1 : a+=k[0]&0xff; break; case 0 : return c; /* zero length strings require no mixing */ } #else /* make valgrind happy */ k8 = (const uint8_t *)k; switch(length) { case 12: c+=k[2]; b+=k[1]; a+=k[0]; break; case 11: c+=((uint32_t)k8[10])<<16; /* fall through */ case 10: c+=((uint32_t)k8[9])<<8; /* fall through */ case 9 : c+=k8[8]; /* fall through */ case 8 : b+=k[1]; a+=k[0]; break; case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */ case 6 : b+=((uint32_t)k8[5])<<8; /* fall through */ case 5 : b+=k8[4]; /* fall through */ case 4 : a+=k[0]; break; case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */ case 2 : a+=((uint32_t)k8[1])<<8; /* fall through */ case 1 : a+=k8[0]; break; case 0 : return c; /* zero length strings require no mixing */ } #endif /* !valgrind */ } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) { const uint16_t *k = key; /* read 16-bit chunks */ const uint8_t *k8; /*--------------- all but last block: aligned reads and different mixing */ while (length > 12) { a += k[0] + (((uint32_t)k[1])<<16); b += k[2] + (((uint32_t)k[3])<<16); c += k[4] + (((uint32_t)k[5])<<16); mix(a,b,c); length -= 12; k += 6; } /*----------------------------- handle the last (probably partial) block */ k8 = (const uint8_t *)k; switch(length) { case 12: c+=k[4]+(((uint32_t)k[5])<<16); b+=k[2]+(((uint32_t)k[3])<<16); a+=k[0]+(((uint32_t)k[1])<<16); break; case 11: c+=((uint32_t)k8[10])<<16; /* @fallthrough */ case 10: c+=k[4]; /* @fallthrough@ */ b+=k[2]+(((uint32_t)k[3])<<16); a+=k[0]+(((uint32_t)k[1])<<16); break; case 9 : c+=k8[8]; /* @fallthrough */ case 8 : b+=k[2]+(((uint32_t)k[3])<<16); a+=k[0]+(((uint32_t)k[1])<<16); break; case 7 : b+=((uint32_t)k8[6])<<16; /* @fallthrough */ case 6 : b+=k[2]; a+=k[0]+(((uint32_t)k[1])<<16); break; case 5 : b+=k8[4]; /* @fallthrough */ case 4 : a+=k[0]+(((uint32_t)k[1])<<16); break; case 3 : a+=((uint32_t)k8[2])<<16; /* @fallthrough */ case 2 : a+=k[0]; break; case 1 : a+=k8[0]; break; case 0 : return c; /* zero length strings require no mixing */ } } else { /* need to read the key one byte at a time */ const uint8_t *k = key; /*--------------- all but the last block: affect some 32 bits of (a,b,c) */ while (length > 12) { a += k[0]; a += ((uint32_t)k[1])<<8; a += ((uint32_t)k[2])<<16; a += ((uint32_t)k[3])<<24; b += k[4]; b += ((uint32_t)k[5])<<8; b += ((uint32_t)k[6])<<16; b += ((uint32_t)k[7])<<24; c += k[8]; c += ((uint32_t)k[9])<<8; c += ((uint32_t)k[10])<<16; c += ((uint32_t)k[11])<<24; mix(a,b,c); length -= 12; k += 12; } /*-------------------------------- last block: affect all 32 bits of (c) */ switch(length) /* all the case statements fall through */ { case 12: c+=((uint32_t)k[11])<<24; case 11: c+=((uint32_t)k[10])<<16; case 10: c+=((uint32_t)k[9])<<8; case 9 : c+=k[8]; case 8 : b+=((uint32_t)k[7])<<24; case 7 : b+=((uint32_t)k[6])<<16; case 6 : b+=((uint32_t)k[5])<<8; case 5 : b+=k[4]; case 4 : a+=((uint32_t)k[3])<<24; case 3 : a+=((uint32_t)k[2])<<16; case 2 : a+=((uint32_t)k[1])<<8; case 1 : a+=k[0]; break; case 0 : return c; /* zero length strings require no mixing */ } } final(a,b,c); return c; /* zero length strings require no mixing */ } #elif HASH_BIG_ENDIAN == 1 /* * hashbig(): * This is the same as hashword() on big-endian machines. It is different * from hashlittle() on all machines. hashbig() takes advantage of * big-endian byte ordering. */ uint32_t jenkins_hash( const void *key, size_t length) { uint32_t a,b,c; union { const void *ptr; size_t i; } u; /* to cast key to (size_t) happily */ /* Set up the internal state */ a = b = c = 0xdeadbeef + ((uint32_t)length) + 0; u.ptr = key; if (HASH_BIG_ENDIAN && ((u.i & 0x3) == 0)) { const uint32_t *k = key; /* read 32-bit chunks */ #ifdef VALGRIND const uint8_t *k8; #endif /* ifdef VALGRIND */ /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */ while (length > 12) { a += k[0]; b += k[1]; c += k[2]; mix(a,b,c); length -= 12; k += 3; } /*----------------------------- handle the last (probably partial) block */ /* * "k[2]<<8" actually reads beyond the end of the string, but * then shifts out the part it's not allowed to read. Because the * string is aligned, the illegal read is in the same word as the * rest of the string. Every machine with memory protection I've seen * does it on word boundaries, so is OK with this. But VALGRIND will * still catch it and complain. The masking trick does make the hash * noticeably faster for short strings (like English words). */ #ifndef VALGRIND switch(length) { case 12: c+=k[2]; b+=k[1]; a+=k[0]; break; case 11: c+=k[2]&0xffffff00; b+=k[1]; a+=k[0]; break; case 10: c+=k[2]&0xffff0000; b+=k[1]; a+=k[0]; break; case 9 : c+=k[2]&0xff000000; b+=k[1]; a+=k[0]; break; case 8 : b+=k[1]; a+=k[0]; break; case 7 : b+=k[1]&0xffffff00; a+=k[0]; break; case 6 : b+=k[1]&0xffff0000; a+=k[0]; break; case 5 : b+=k[1]&0xff000000; a+=k[0]; break; case 4 : a+=k[0]; break; case 3 : a+=k[0]&0xffffff00; break; case 2 : a+=k[0]&0xffff0000; break; case 1 : a+=k[0]&0xff000000; break; case 0 : return c; /* zero length strings require no mixing */ } #else /* make valgrind happy */ k8 = (const uint8_t *)k; switch(length) /* all the case statements fall through */ { case 12: c+=k[2]; b+=k[1]; a+=k[0]; break; case 11: c+=((uint32_t)k8[10])<<8; /* fall through */ case 10: c+=((uint32_t)k8[9])<<16; /* fall through */ case 9 : c+=((uint32_t)k8[8])<<24; /* fall through */ case 8 : b+=k[1]; a+=k[0]; break; case 7 : b+=((uint32_t)k8[6])<<8; /* fall through */ case 6 : b+=((uint32_t)k8[5])<<16; /* fall through */ case 5 : b+=((uint32_t)k8[4])<<24; /* fall through */ case 4 : a+=k[0]; break; case 3 : a+=((uint32_t)k8[2])<<8; /* fall through */ case 2 : a+=((uint32_t)k8[1])<<16; /* fall through */ case 1 : a+=((uint32_t)k8[0])<<24; break; case 0 : return c; } #endif /* !VALGRIND */ } else { /* need to read the key one byte at a time */ const uint8_t *k = key; /*--------------- all but the last block: affect some 32 bits of (a,b,c) */ while (length > 12) { a += ((uint32_t)k[0])<<24; a += ((uint32_t)k[1])<<16; a += ((uint32_t)k[2])<<8; a += ((uint32_t)k[3]); b += ((uint32_t)k[4])<<24; b += ((uint32_t)k[5])<<16; b += ((uint32_t)k[6])<<8; b += ((uint32_t)k[7]); c += ((uint32_t)k[8])<<24; c += ((uint32_t)k[9])<<16; c += ((uint32_t)k[10])<<8; c += ((uint32_t)k[11]); mix(a,b,c); length -= 12; k += 12; } /*-------------------------------- last block: affect all 32 bits of (c) */ switch(length) /* all the case statements fall through */ { case 12: c+=k[11]; case 11: c+=((uint32_t)k[10])<<8; case 10: c+=((uint32_t)k[9])<<16; case 9 : c+=((uint32_t)k[8])<<24; case 8 : b+=k[7]; case 7 : b+=((uint32_t)k[6])<<8; case 6 : b+=((uint32_t)k[5])<<16; case 5 : b+=((uint32_t)k[4])<<24; case 4 : a+=k[3]; case 3 : a+=((uint32_t)k[2])<<8; case 2 : a+=((uint32_t)k[1])<<16; case 1 : a+=((uint32_t)k[0])<<24; break; case 0 : return c; } } final(a,b,c); return c; } #else /* HASH_XXX_ENDIAN == 1 */ #error Must define HASH_BIG_ENDIAN or HASH_LITTLE_ENDIAN #endif /* HASH_XXX_ENDIAN == 1 */ memcached-1.6.20/proto_text.h0000664000175000017500000000036614340006077013017 00000000000000#ifndef PROTO_TEXT_H #define PROTO_TEXT_H /* text protocol handlers */ void complete_nread_ascii(conn *c); int try_read_command_asciiauth(conn *c); int try_read_command_ascii(conn *c); void process_command_ascii(conn *c, char *command); #endif memcached-1.6.20/slab_automove.c0000664000175000017500000001313714340006077013443 00000000000000/* Copyright 2017 Facebook. * * Use and distribution licensed under the BSD license. See * the LICENSE file for full text. */ /* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "memcached.h" #include "slab_automove.h" #include #include #define MIN_PAGES_FOR_SOURCE 2 #define MIN_PAGES_FOR_RECLAIM 2.5 struct window_data { uint64_t age; uint64_t dirty; float evicted_ratio; uint64_t evicted_seen; // if evictions were seen at all this window }; typedef struct { struct window_data *window_data; uint32_t window_size; uint32_t window_cur; double max_age_ratio; item_stats_automove iam_before[MAX_NUMBER_OF_SLAB_CLASSES]; item_stats_automove iam_after[MAX_NUMBER_OF_SLAB_CLASSES]; slab_stats_automove sam_before[MAX_NUMBER_OF_SLAB_CLASSES]; slab_stats_automove sam_after[MAX_NUMBER_OF_SLAB_CLASSES]; } slab_automove; void *slab_automove_init(struct settings *settings) { uint32_t window_size = settings->slab_automove_window; double max_age_ratio = settings->slab_automove_ratio; slab_automove *a = calloc(1, sizeof(slab_automove)); if (a == NULL) return NULL; a->window_data = calloc(window_size * MAX_NUMBER_OF_SLAB_CLASSES, sizeof(struct window_data)); a->window_size = window_size; a->max_age_ratio = max_age_ratio; if (a->window_data == NULL) { free(a); return NULL; } // do a dry run to fill the before structs fill_item_stats_automove(a->iam_before); fill_slab_stats_automove(a->sam_before); return (void *)a; } void slab_automove_free(void *arg) { slab_automove *a = (slab_automove *)arg; free(a->window_data); free(a); } static void window_sum(struct window_data *wd, struct window_data *w, uint32_t size) { int x; for (x = 0; x < size; x++) { struct window_data *d = &wd[x]; w->age += d->age; w->dirty += d->dirty; w->evicted_ratio += d->evicted_ratio; w->evicted_seen += d->evicted_seen; } } // TODO: if oldest is dirty, find next oldest. // still need to base ratio off of absolute age void slab_automove_run(void *arg, int *src, int *dst) { slab_automove *a = (slab_automove *)arg; int n; struct window_data w_sum; int oldest = -1; uint64_t oldest_age = 0; int youngest = -1; uint64_t youngest_age = ~0; bool youngest_evicting = false; *src = -1; *dst = -1; // fill after structs fill_item_stats_automove(a->iam_after); fill_slab_stats_automove(a->sam_after); // Loop once to get total_evicted for this window. uint64_t evicted_total = 0; for (n = POWER_SMALLEST; n < MAX_NUMBER_OF_SLAB_CLASSES; n++) { evicted_total += a->iam_after[n].evicted - a->iam_before[n].evicted; } a->window_cur++; // iterate slabs for (n = POWER_SMALLEST; n < MAX_NUMBER_OF_SLAB_CLASSES; n++) { int w_offset = n * a->window_size; struct window_data *wd = &a->window_data[w_offset + (a->window_cur % a->window_size)]; memset(wd, 0, sizeof(struct window_data)); // if page delta, or evicted delta, mark window dirty // (or outofmemory) uint64_t evicted_delta = a->iam_after[n].evicted - a->iam_before[n].evicted; if (evicted_delta > 0) { // FIXME: the python script is using floats. we have ints. wd->evicted_ratio = (float) evicted_delta / evicted_total; wd->evicted_seen = 1; wd->dirty = 1; } if (a->iam_after[n].outofmemory - a->iam_before[n].outofmemory > 0) { wd->dirty = 1; } if (a->sam_after[n].total_pages - a->sam_before[n].total_pages > 0) { wd->dirty = 1; } // set age into window wd->age = a->iam_after[n].age; // summarize the window-up-to-now. memset(&w_sum, 0, sizeof(struct window_data)); window_sum(&a->window_data[w_offset], &w_sum, a->window_size); // grab age as average of window total uint64_t age = w_sum.age / a->window_size; // if > N free chunks and not dirty, make decision. if (a->sam_after[n].free_chunks > a->sam_after[n].chunks_per_page * MIN_PAGES_FOR_RECLAIM) { if (w_sum.dirty == 0) { *src = n; *dst = 0; youngest = oldest = -1; break; } } // if oldest and have enough pages, is oldest if (age > oldest_age && a->sam_after[n].total_pages > MIN_PAGES_FOR_SOURCE) { oldest = n; oldest_age = age; } // grab evicted count from window // if > half the window and youngest, mark as youngest // or, if more than 25% of total evictions in the window. if (age < youngest_age && (w_sum.evicted_seen > a->window_size / 2 || w_sum.evicted_ratio / a->window_size > 0.25)) { youngest = n; youngest_age = age; youngest_evicting = wd->evicted_seen ? true : false; } } memcpy(a->iam_before, a->iam_after, sizeof(item_stats_automove) * MAX_NUMBER_OF_SLAB_CLASSES); memcpy(a->sam_before, a->sam_after, sizeof(slab_stats_automove) * MAX_NUMBER_OF_SLAB_CLASSES); // if we have a youngest and oldest, and oldest is outside the ratio, // also, only make decisions if window has filled once. if (youngest != -1 && oldest != -1 && a->window_cur > a->window_size) { if (youngest_age < ((double)oldest_age * a->max_age_ratio) && youngest_evicting) { *src = oldest; *dst = youngest; } } return; } memcached-1.6.20/trace.h0000664000175000017500000000613713704126374011716 00000000000000#ifndef TRACE_H #define TRACE_H #ifdef ENABLE_DTRACE #include "memcached_dtrace.h" #else #define MEMCACHED_ASSOC_DELETE(arg0, arg1) #define MEMCACHED_ASSOC_DELETE_ENABLED() (0) #define MEMCACHED_ASSOC_FIND(arg0, arg1, arg2) #define MEMCACHED_ASSOC_FIND_ENABLED() (0) #define MEMCACHED_ASSOC_INSERT(arg0, arg1) #define MEMCACHED_ASSOC_INSERT_ENABLED() (0) #define MEMCACHED_COMMAND_ADD(arg0, arg1, arg2, arg3, arg4) #define MEMCACHED_COMMAND_ADD_ENABLED() (0) #define MEMCACHED_COMMAND_APPEND(arg0, arg1, arg2, arg3, arg4) #define MEMCACHED_COMMAND_APPEND_ENABLED() (0) #define MEMCACHED_COMMAND_CAS(arg0, arg1, arg2, arg3, arg4) #define MEMCACHED_COMMAND_CAS_ENABLED() (0) #define MEMCACHED_COMMAND_DECR(arg0, arg1, arg2, arg3) #define MEMCACHED_COMMAND_DECR_ENABLED() (0) #define MEMCACHED_COMMAND_DELETE(arg0, arg1, arg2) #define MEMCACHED_COMMAND_DELETE_ENABLED() (0) #define MEMCACHED_COMMAND_GET(arg0, arg1, arg2, arg3, arg4) #define MEMCACHED_COMMAND_GET_ENABLED() (0) #define MEMCACHED_COMMAND_TOUCH(arg0, arg1, arg2, arg3, arg4) #define MEMCACHED_COMMAND_TOUCH_ENABLED() (0) #define MEMCACHED_COMMAND_INCR(arg0, arg1, arg2, arg3) #define MEMCACHED_COMMAND_INCR_ENABLED() (0) #define MEMCACHED_COMMAND_PREPEND(arg0, arg1, arg2, arg3, arg4) #define MEMCACHED_COMMAND_PREPEND_ENABLED() (0) #define MEMCACHED_COMMAND_REPLACE(arg0, arg1, arg2, arg3, arg4) #define MEMCACHED_COMMAND_REPLACE_ENABLED() (0) #define MEMCACHED_COMMAND_SET(arg0, arg1, arg2, arg3, arg4) #define MEMCACHED_COMMAND_SET_ENABLED() (0) #define MEMCACHED_CONN_ALLOCATE(arg0) #define MEMCACHED_CONN_ALLOCATE_ENABLED() (0) #define MEMCACHED_CONN_CREATE(arg0) #define MEMCACHED_CONN_CREATE_ENABLED() (0) #define MEMCACHED_CONN_DESTROY(arg0) #define MEMCACHED_CONN_DESTROY_ENABLED() (0) #define MEMCACHED_CONN_DISPATCH(arg0, arg1) #define MEMCACHED_CONN_DISPATCH_ENABLED() (0) #define MEMCACHED_CONN_RELEASE(arg0) #define MEMCACHED_CONN_RELEASE_ENABLED() (0) #define MEMCACHED_ITEM_LINK(arg0, arg1, arg2) #define MEMCACHED_ITEM_LINK_ENABLED() (0) #define MEMCACHED_ITEM_REMOVE(arg0, arg1, arg2) #define MEMCACHED_ITEM_REMOVE_ENABLED() (0) #define MEMCACHED_ITEM_REPLACE(arg0, arg1, arg2, arg3, arg4, arg5) #define MEMCACHED_ITEM_REPLACE_ENABLED() (0) #define MEMCACHED_ITEM_UNLINK(arg0, arg1, arg2) #define MEMCACHED_ITEM_UNLINK_ENABLED() (0) #define MEMCACHED_ITEM_UPDATE(arg0, arg1, arg2) #define MEMCACHED_ITEM_UPDATE_ENABLED() (0) #define MEMCACHED_PROCESS_COMMAND_END(arg0, arg1, arg2) #define MEMCACHED_PROCESS_COMMAND_END_ENABLED() (0) #define MEMCACHED_PROCESS_COMMAND_START(arg0, arg1, arg2) #define MEMCACHED_PROCESS_COMMAND_START_ENABLED() (0) #define MEMCACHED_SLABS_ALLOCATE(arg0, arg1, arg2, arg3) #define MEMCACHED_SLABS_ALLOCATE_ENABLED() (0) #define MEMCACHED_SLABS_ALLOCATE_FAILED(arg0, arg1) #define MEMCACHED_SLABS_ALLOCATE_FAILED_ENABLED() (0) #define MEMCACHED_SLABS_FREE(arg0, arg1, arg2) #define MEMCACHED_SLABS_FREE_ENABLED() (0) #define MEMCACHED_SLABS_SLABCLASS_ALLOCATE(arg0) #define MEMCACHED_SLABS_SLABCLASS_ALLOCATE_ENABLED() (0) #define MEMCACHED_SLABS_SLABCLASS_ALLOCATE_FAILED(arg0) #define MEMCACHED_SLABS_SLABCLASS_ALLOCATE_FAILED_ENABLED() (0) #endif #endif memcached-1.6.20/openbsd_priv.c0000664000175000017500000000163114204760331013270 00000000000000#include #include #include #include #include #include "memcached.h" /* * this section of code will drop all (OpenBSD) privileges including * those normally granted to all userland process (basic privileges). The * effect of this is that after running this code, the process will not able * to fork(), exec(), etc. See pledge(2) for more information. */ void drop_privileges() { extern char *__progname; if (settings.socketpath != NULL) { if (pledge("stdio unix", NULL) == -1) { fprintf(stderr, "%s: pledge: %s\n", __progname, strerror(errno)); exit(EXIT_FAILURE); } } else { if (pledge("stdio inet", NULL) == -1) { fprintf(stderr, "%s: pledge: %s\n", __progname, strerror(errno)); exit(EXIT_FAILURE); } } } void setup_privilege_violations_handler(void) { // not needed } memcached-1.6.20/testapp.c0000664000175000017500000023201614357451302012265 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #undef NDEBUG #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "config.h" #include "cache.h" #include "crc32c.h" #include "hash.h" #include "jenkins_hash.h" #include "stats_prefix.h" #include "util.h" #include "protocol_binary.h" #ifdef TLS #include #endif #define TMP_TEMPLATE "/tmp/test_file.XXXXXXX" enum test_return { TEST_SKIP, TEST_PASS, TEST_FAIL }; struct conn { int sock; #ifdef TLS SSL_CTX *ssl_ctx; SSL *ssl; #endif ssize_t (*read)(struct conn *c, void *buf, size_t count); ssize_t (*write)(struct conn *c, const void *buf, size_t count); }; hash_func hash; static ssize_t tcp_read(struct conn *c, void *buf, size_t count); static ssize_t tcp_write(struct conn *c, const void *buf, size_t count); #ifdef TLS static ssize_t ssl_read(struct conn *c, void *buf, size_t count); static ssize_t ssl_write(struct conn *c, const void *buf, size_t count); #endif ssize_t tcp_read(struct conn *c, void *buf, size_t count) { assert(c != NULL); return read(c->sock, buf, count); } ssize_t tcp_write(struct conn *c, const void *buf, size_t count) { assert(c != NULL); return write(c->sock, buf, count); } #ifdef TLS ssize_t ssl_read(struct conn *c, void *buf, size_t count) { assert(c != NULL); return SSL_read(c->ssl, buf, count); } ssize_t ssl_write(struct conn *c, const void *buf, size_t count) { assert(c != NULL); return SSL_write(c->ssl, buf, count); } #endif static pid_t server_pid; static in_port_t port; static struct conn *con = NULL; static bool allow_closed_read = false; static bool enable_ssl = false; static void close_conn(void) { if (con == NULL) return; #ifdef TLS if (con->ssl) { SSL_shutdown(con->ssl); SSL_free(con->ssl); } if (con->ssl_ctx) SSL_CTX_free(con->ssl_ctx); #endif if (con->sock > 0) close(con->sock); free(con); con = NULL; } static enum test_return cache_create_test(void) { cache_t *cache = cache_create("test", sizeof(uint32_t), sizeof(char*)); assert(cache != NULL); cache_destroy(cache); return TEST_PASS; } static enum test_return cache_reuse_test(void) { int ii; cache_t *cache = cache_create("test", sizeof(uint32_t), sizeof(char*)); if (cache == NULL) { return TEST_FAIL; } char *ptr = cache_alloc(cache); cache_free(cache, ptr); for (ii = 0; ii < 100; ++ii) { char *p = cache_alloc(cache); assert(p == ptr); cache_free(cache, ptr); } cache_destroy(cache); return TEST_PASS; } static enum test_return cache_bulkalloc(size_t datasize) { cache_t *cache = cache_create("test", datasize, sizeof(char*)); if (cache == NULL) { return TEST_FAIL; } #define ITERATIONS 1024 void *ptr[ITERATIONS]; for (int ii = 0; ii < ITERATIONS; ++ii) { ptr[ii] = cache_alloc(cache); assert(ptr[ii] != 0); memset(ptr[ii], 0xff, datasize); } for (int ii = 0; ii < ITERATIONS; ++ii) { cache_free(cache, ptr[ii]); } #undef ITERATIONS cache_destroy(cache); return TEST_PASS; } static enum test_return test_issue_161(void) { enum test_return ret = cache_bulkalloc(1); if (ret == TEST_PASS) { ret = cache_bulkalloc(512); } return ret; } static enum test_return cache_redzone_test(void) { #ifndef HAVE_UMEM_H cache_t *cache = cache_create("test", sizeof(uint32_t), sizeof(char*)); if (cache == NULL) { return TEST_FAIL; } /* Ignore SIGABRT */ struct sigaction old_action; struct sigaction action = { .sa_handler = SIG_IGN, .sa_flags = 0}; sigemptyset(&action.sa_mask); sigaction(SIGABRT, &action, &old_action); /* check memory debug.. */ char *p = cache_alloc(cache); char old = *(p - 1); *(p - 1) = 0; cache_free(cache, p); assert(cache_error == -1); *(p - 1) = old; p[sizeof(uint32_t)] = 0; cache_free(cache, p); assert(cache_error == 1); /* restore signal handler */ sigaction(SIGABRT, &old_action, NULL); cache_destroy(cache); return TEST_PASS; #else return TEST_SKIP; #endif } static enum test_return cache_limit_revised_downward_test(void) { int limit = 10, allocated_num = limit + 1, i; char ** alloc_objs = calloc(allocated_num, sizeof(char *)); cache_t *cache = cache_create("test", sizeof(uint32_t), sizeof(char*)); assert(cache != NULL); /* cache->limit is 0 and we can allocate limit+1 items */ for (i = 0; i < allocated_num; i++) { alloc_objs[i] = cache_alloc(cache); assert(alloc_objs[i] != NULL); } assert(cache->total == allocated_num); /* revised downward cache->limit */ cache_set_limit(cache, limit); /* If we free one item, the cache->total should decreased by one*/ cache_free(cache, alloc_objs[0]); assert(cache->total == allocated_num-1); cache_destroy(cache); free(alloc_objs); return TEST_PASS; } static enum test_return test_stats_prefix_find(void) { PREFIX_STATS *pfs1, *pfs2; stats_prefix_clear(); pfs1 = stats_prefix_find("abc", 3); assert(pfs1 == NULL); pfs1 = stats_prefix_find("abc|", 4); assert(pfs1 == NULL); pfs1 = stats_prefix_find("abc:", 4); assert(pfs1 != NULL); assert(0ULL == (pfs1->num_gets + pfs1->num_sets + pfs1->num_deletes + pfs1->num_hits)); pfs2 = stats_prefix_find("abc:", 4); assert(pfs1 == pfs2); pfs2 = stats_prefix_find("abc:d", 5); assert(pfs1 == pfs2); pfs2 = stats_prefix_find("xyz123:", 6); assert(pfs1 != pfs2); pfs2 = stats_prefix_find("ab:", 3); assert(pfs1 != pfs2); return TEST_PASS; } static enum test_return test_stats_prefix_record_get(void) { PREFIX_STATS *pfs; stats_prefix_clear(); stats_prefix_record_get("abc:123", 7, false); pfs = stats_prefix_find("abc:123", 7); if (pfs == NULL) { return TEST_FAIL; } assert(1 == pfs->num_gets); assert(0 == pfs->num_hits); stats_prefix_record_get("abc:456", 7, false); assert(2 == pfs->num_gets); assert(0 == pfs->num_hits); stats_prefix_record_get("abc:456", 7, true); assert(3 == pfs->num_gets); assert(1 == pfs->num_hits); stats_prefix_record_get("def:", 4, true); assert(3 == pfs->num_gets); assert(1 == pfs->num_hits); return TEST_PASS; } static enum test_return test_stats_prefix_record_delete(void) { PREFIX_STATS *pfs; stats_prefix_clear(); stats_prefix_record_delete("abc:123", 7); pfs = stats_prefix_find("abc:123", 7); if (pfs == NULL) { return TEST_FAIL; } assert(0 == pfs->num_gets); assert(0 == pfs->num_hits); assert(1 == pfs->num_deletes); assert(0 == pfs->num_sets); stats_prefix_record_delete("def:", 4); assert(1 == pfs->num_deletes); return TEST_PASS; } static enum test_return test_stats_prefix_record_set(void) { PREFIX_STATS *pfs; stats_prefix_clear(); stats_prefix_record_set("abc:123", 7); pfs = stats_prefix_find("abc:123", 7); if (pfs == NULL) { return TEST_FAIL; } assert(0 == pfs->num_gets); assert(0 == pfs->num_hits); assert(0 == pfs->num_deletes); assert(1 == pfs->num_sets); stats_prefix_record_delete("def:", 4); assert(1 == pfs->num_sets); return TEST_PASS; } static enum test_return test_stats_prefix_dump(void) { int hashval = hash("abc", 3) % PREFIX_HASH_SIZE; char tmp[500]; char *buf; const char *expected; int keynum; int length; stats_prefix_clear(); assert(strcmp("END\r\n", (buf = stats_prefix_dump(&length))) == 0); assert(5 == length); stats_prefix_record_set("abc:123", 7); free(buf); expected = "PREFIX abc get 0 hit 0 set 1 del 0\r\nEND\r\n"; assert(strcmp(expected, (buf = stats_prefix_dump(&length))) == 0); assert(strlen(expected) == length); stats_prefix_record_get("abc:123", 7, false); free(buf); expected = "PREFIX abc get 1 hit 0 set 1 del 0\r\nEND\r\n"; assert(strcmp(expected, (buf = stats_prefix_dump(&length))) == 0); assert(strlen(expected) == length); stats_prefix_record_get("abc:123", 7, true); free(buf); expected = "PREFIX abc get 2 hit 1 set 1 del 0\r\nEND\r\n"; assert(strcmp(expected, (buf = stats_prefix_dump(&length))) == 0); assert(strlen(expected) == length); stats_prefix_record_delete("abc:123", 7); free(buf); expected = "PREFIX abc get 2 hit 1 set 1 del 1\r\nEND\r\n"; assert(strcmp(expected, (buf = stats_prefix_dump(&length))) == 0); assert(strlen(expected) == length); stats_prefix_record_delete("def:123", 7); free(buf); /* NOTE: Prefixes can be dumped in any order, so we verify that each expected line is present in the string. */ buf = stats_prefix_dump(&length); assert(strstr(buf, "PREFIX abc get 2 hit 1 set 1 del 1\r\n") != NULL); assert(strstr(buf, "PREFIX def get 0 hit 0 set 0 del 1\r\n") != NULL); assert(strstr(buf, "END\r\n") != NULL); free(buf); /* Find a key that hashes to the same bucket as "abc" */ bool found_match = false; for (keynum = 0; keynum < PREFIX_HASH_SIZE * 100; keynum++) { snprintf(tmp, sizeof(tmp), "%d:", keynum); /* -1 because only the prefix portion is used when hashing */ if (hashval == hash(tmp, strlen(tmp) - 1) % PREFIX_HASH_SIZE) { found_match = true; break; } } assert(found_match); stats_prefix_record_set(tmp, strlen(tmp)); buf = stats_prefix_dump(&length); assert(strstr(buf, "PREFIX abc get 2 hit 1 set 1 del 1\r\n") != NULL); assert(strstr(buf, "PREFIX def get 0 hit 0 set 0 del 1\r\n") != NULL); assert(strstr(buf, "END\r\n") != NULL); snprintf(tmp, sizeof(tmp), "PREFIX %d get 0 hit 0 set 1 del 0\r\n", keynum); assert(strstr(buf, tmp) != NULL); free(buf); /* Marking the end of these tests */ stats_prefix_clear(); return TEST_PASS; } static enum test_return test_safe_strtoul(void) { uint32_t val; assert(safe_strtoul("123", &val)); assert(val == 123); assert(safe_strtoul("+123", &val)); assert(val == 123); assert(!safe_strtoul("", &val)); // empty assert(!safe_strtoul("123BOGUS", &val)); // non-numeric assert(!safe_strtoul(" issue221", &val)); // non-numeric /* Not sure what it does, but this works with ICC :/ assert(!safe_strtoul("92837498237498237498029383", &val)); // out of range */ // extremes: assert(safe_strtoul("4294967295", &val)); // 2**32 - 1 assert(val == 4294967295L); /* This actually works on 64-bit ubuntu assert(!safe_strtoul("4294967296", &val)); // 2**32 */ assert(!safe_strtoul("-1", &val)); // negative return TEST_PASS; } static enum test_return test_safe_strtoull(void) { uint64_t val; assert(safe_strtoull("123", &val)); assert(val == 123); assert(safe_strtoull("+123", &val)); assert(val == 123); assert(!safe_strtoull("", &val)); // empty assert(!safe_strtoull("123BOGUS", &val)); // non-numeric assert(!safe_strtoull("92837498237498237498029383", &val)); // out of range assert(!safe_strtoull(" issue221", &val)); // non-numeric // extremes: assert(safe_strtoull("18446744073709551615", &val)); // 2**64 - 1 assert(val == 18446744073709551615ULL); assert(!safe_strtoull("18446744073709551616", &val)); // 2**64 assert(!safe_strtoull("-1", &val)); // negative return TEST_PASS; } static enum test_return test_safe_strtoll(void) { int64_t val; assert(safe_strtoll("123", &val)); assert(val == 123); assert(safe_strtoll("+123", &val)); assert(val == 123); assert(safe_strtoll("-123", &val)); assert(val == -123); assert(!safe_strtoll("", &val)); // empty assert(!safe_strtoll("123BOGUS", &val)); // non-numeric assert(!safe_strtoll("92837498237498237498029383", &val)); // out of range assert(!safe_strtoll(" issue221", &val)); // non-numeric // extremes: assert(!safe_strtoll("18446744073709551615", &val)); // 2**64 - 1 assert(safe_strtoll("9223372036854775807", &val)); // 2**63 - 1 assert(val == 9223372036854775807LL); /* assert(safe_strtoll("-9223372036854775808", &val)); // -2**63 assert(val == -9223372036854775808LL); */ assert(!safe_strtoll("-9223372036854775809", &val)); // -2**63 - 1 // We'll allow space to terminate the string. And leading space. assert(safe_strtoll(" 123 foo", &val)); assert(val == 123); return TEST_PASS; } static enum test_return test_safe_strtol(void) { int32_t val; assert(safe_strtol("123", &val)); assert(val == 123); assert(safe_strtol("+123", &val)); assert(val == 123); assert(safe_strtol("-123", &val)); assert(val == -123); assert(!safe_strtol("", &val)); // empty assert(!safe_strtol("123BOGUS", &val)); // non-numeric assert(!safe_strtol("92837498237498237498029383", &val)); // out of range assert(!safe_strtol(" issue221", &val)); // non-numeric // extremes: /* This actually works on 64-bit ubuntu assert(!safe_strtol("2147483648", &val)); // (expt 2.0 31.0) */ assert(safe_strtol("2147483647", &val)); // (- (expt 2.0 31) 1) assert(val == 2147483647L); /* This actually works on 64-bit ubuntu assert(!safe_strtol("-2147483649", &val)); // (- (expt -2.0 31) 1) */ // We'll allow space to terminate the string. And leading space. assert(safe_strtol(" 123 foo", &val)); assert(val == 123); return TEST_PASS; } /** * Function to start the server and let it listen on a random port * * @param port_out where to store the TCP port number the server is * listening on * @param daemon set to true if you want to run the memcached server * as a daemon process * @return the pid of the memcached server */ static pid_t start_server(in_port_t *port_out, bool daemon, int timeout) { char environment[80]; snprintf(environment, sizeof(environment), "MEMCACHED_PORT_FILENAME=/tmp/ports.%lu", (long)getpid()); char *filename= environment + strlen("MEMCACHED_PORT_FILENAME="); char pid_file[80]; snprintf(pid_file, sizeof(pid_file), "/tmp/pid.%lu", (long)getpid()); remove(filename); remove(pid_file); #ifdef __sun /* I want to name the corefiles differently so that they don't overwrite each other */ char coreadm[128]; snprintf(coreadm, sizeof(coreadm), "coreadm -p core.%%f.%%p %lu", (unsigned long)getpid()); system(coreadm); #endif pid_t pid = fork(); assert(pid != -1); if (pid == 0) { /* Child */ char *argv[24]; int arg = 0; char tmo[24]; snprintf(tmo, sizeof(tmo), "%u", timeout); putenv(environment); #ifdef __sun putenv("LD_PRELOAD=watchmalloc.so.1"); putenv("MALLOC_DEBUG=WATCH"); #endif if (!daemon) { argv[arg++] = "./timedrun"; argv[arg++] = tmo; } argv[arg++] = "./memcached-debug"; argv[arg++] = "-A"; argv[arg++] = "-p"; argv[arg++] = "-1"; argv[arg++] = "-U"; argv[arg++] = "0"; #ifdef TLS if (enable_ssl) { argv[arg++] = "-Z"; argv[arg++] = "-o"; argv[arg++] = "ssl_chain_cert=t/server_crt.pem"; argv[arg++] = "-o"; argv[arg++] = "ssl_key=t/server_key.pem"; } #endif /* Handle rpmbuild and the like doing this as root */ if (getuid() == 0) { argv[arg++] = "-u"; argv[arg++] = "root"; } if (daemon) { argv[arg++] = "-d"; argv[arg++] = "-P"; argv[arg++] = pid_file; } #ifdef MESSAGE_DEBUG argv[arg++] = "-vvv"; #endif #ifdef HAVE_DROP_PRIVILEGES argv[arg++] = "-o"; argv[arg++] = "relaxed_privileges"; #endif argv[arg++] = NULL; assert(execv(argv[0], argv) != -1); } /* Yeah just let us "busy-wait" for the file to be created ;-) */ useconds_t wait_timeout = 1000000 * 10; useconds_t wait = 1000; while (access(filename, F_OK) == -1 && wait_timeout > 0) { usleep(wait); wait_timeout -= (wait > wait_timeout ? wait_timeout : wait); } if (access(filename, F_OK) == -1) { fprintf(stderr, "Failed to start the memcached server.\n"); assert(false); } FILE *fp = fopen(filename, "r"); if (fp == NULL) { fprintf(stderr, "Failed to open the file containing port numbers: %s\n", strerror(errno)); assert(false); } *port_out = (in_port_t)-1; char buffer[80]; while ((fgets(buffer, sizeof(buffer), fp)) != NULL) { if (strncmp(buffer, "TCP INET: ", 10) == 0) { int32_t val; assert(safe_strtol(buffer + 10, &val)); *port_out = (in_port_t)val; } } fclose(fp); assert(remove(filename) == 0); if (daemon) { /* loop and wait for the pid file.. There is a potential race * condition that the server just created the file but isn't * finished writing the content, so we loop a few times * reading as well */ while (access(pid_file, F_OK) == -1) { usleep(10); } fp = fopen(pid_file, "r"); if (fp == NULL) { fprintf(stderr, "Failed to open pid file: %s\n", strerror(errno)); assert(false); } /* Avoid race by retrying 20 times */ for (int x = 0; x < 20 && fgets(buffer, sizeof(buffer), fp) == NULL; x++) { usleep(10); } fclose(fp); int32_t val; assert(safe_strtol(buffer, &val)); pid = (pid_t)val; } return pid; } static enum test_return test_issue_44(void) { in_port_t port; pid_t pid = start_server(&port, true, 600); assert(kill(pid, SIGHUP) == 0); sleep(1); assert(kill(pid, SIGTERM) == 0); return TEST_PASS; } static struct addrinfo *lookuphost(const char *hostname, in_port_t port) { struct addrinfo *ai = 0; struct addrinfo hints = { .ai_family = AF_UNSPEC, .ai_protocol = IPPROTO_TCP, .ai_socktype = SOCK_STREAM }; char service[NI_MAXSERV]; int error; (void)snprintf(service, NI_MAXSERV, "%d", port); if ((error = getaddrinfo(hostname, service, &hints, &ai)) != 0) { if (error != EAI_SYSTEM) { fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(error)); } else { perror("getaddrinfo()"); } } return ai; } static struct conn *connect_server(const char *hostname, in_port_t port, bool nonblock, const bool ssl) { struct conn *c; if (!(c = (struct conn *)calloc(1, sizeof(struct conn)))) { fprintf(stderr, "Failed to allocate the client connection: %s\n", strerror(errno)); return NULL; } struct addrinfo *ai = lookuphost(hostname, port); int sock = -1; if (ai != NULL) { if ((sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)) != -1) { if (connect(sock, ai->ai_addr, ai->ai_addrlen) == -1) { fprintf(stderr, "Failed to connect socket: %s\n", strerror(errno)); close(sock); sock = -1; } else if (nonblock) { int flags = fcntl(sock, F_GETFL, 0); if (flags < 0 || fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) { fprintf(stderr, "Failed to enable nonblocking mode: %s\n", strerror(errno)); close(sock); sock = -1; } } } else { fprintf(stderr, "Failed to create socket: %s\n", strerror(errno)); } freeaddrinfo(ai); } c->sock = sock; #ifdef TLS if (sock > 0 && ssl) { c->ssl_ctx = SSL_CTX_new(SSLv23_client_method()); if (c->ssl_ctx == NULL) { fprintf(stderr, "Failed to create the SSL context: %s\n", strerror(errno)); close(sock); sock = -1; } c->ssl = SSL_new(c->ssl_ctx); if (c->ssl == NULL) { fprintf(stderr, "Failed to create the SSL object: %s\n", strerror(errno)); close(sock); sock = -1; } SSL_set_fd (c->ssl, c->sock); int ret = SSL_connect(c->ssl); if (ret < 0) { int err = SSL_get_error(c->ssl, ret); if (err == SSL_ERROR_SYSCALL || err == SSL_ERROR_SSL) { fprintf(stderr, "SSL connection failed with error code : %s\n", strerror(errno)); close(sock); sock = -1; } } c->read = ssl_read; c->write = ssl_write; } else #endif { c->read = tcp_read; c->write = tcp_write; } return c; } static enum test_return test_vperror(void) { int rv = 0; int oldstderr = dup(STDERR_FILENO); assert(oldstderr >= 0); char tmpl[sizeof(TMP_TEMPLATE)+1]; strncpy(tmpl, TMP_TEMPLATE, sizeof(TMP_TEMPLATE)+1); int newfile = mkstemp(tmpl); assert(newfile > 0); rv = dup2(newfile, STDERR_FILENO); assert(rv == STDERR_FILENO); rv = close(newfile); assert(rv == 0); errno = EIO; vperror("Old McDonald had a farm. %s", "EI EIO"); /* Restore stderr */ rv = dup2(oldstderr, STDERR_FILENO); assert(rv == STDERR_FILENO); /* Go read the file */ char buf[80] = { 0 }; FILE *efile = fopen(tmpl, "r"); assert(efile); char *prv = fgets(buf, sizeof(buf), efile); assert(prv); fclose(efile); unlink(tmpl); char expected[80] = { 0 }; snprintf(expected, sizeof(expected), "Old McDonald had a farm. EI EIO: %s\n", strerror(EIO)); /* fprintf(stderr, "\nExpected: ``%s''" "\nGot: ``%s''\n", expected, buf); */ return strcmp(expected, buf) == 0 ? TEST_PASS : TEST_FAIL; } static void send_ascii_command(const char *buf) { off_t offset = 0; const char* ptr = buf; size_t len = strlen(buf); do { ssize_t nw = con->write((void*)con, ptr + offset, len - offset); if (nw == -1) { if (errno != EINTR) { fprintf(stderr, "Failed to write: %s\n", strerror(errno)); abort(); } } else { offset += nw; } } while (offset < len); } /* * This is a dead slow single byte read, but it should only read out * _one_ response and I don't have an input buffer... The current * implementation only supports single-line responses, so if you want to use * it for get commands you need to implement that first ;-) */ static void read_ascii_response(char *buffer, size_t size) { off_t offset = 0; bool need_more = true; do { ssize_t nr = con->read(con, buffer + offset, 1); if (nr == -1) { if (errno != EINTR) { fprintf(stderr, "Failed to read: %s\n", strerror(errno)); abort(); } } else { assert(nr == 1); if (buffer[offset] == '\n') { need_more = false; buffer[offset + 1] = '\0'; } offset += nr; assert(offset + 1 < size); } } while (need_more); } static enum test_return test_issue_92(void) { char buffer[1024]; close_conn(); con = connect_server("127.0.0.1", port, false, enable_ssl); assert(con); send_ascii_command("stats cachedump 1 0 0\r\n"); read_ascii_response(buffer, sizeof(buffer)); assert(strncmp(buffer, "END", strlen("END")) == 0); send_ascii_command("stats cachedump 200 0 0\r\n"); read_ascii_response(buffer, sizeof(buffer)); assert(strncmp(buffer, "CLIENT_ERROR", strlen("CLIENT_ERROR")) == 0); close_conn(); con = connect_server("127.0.0.1", port, false, enable_ssl); assert(con); return TEST_PASS; } static enum test_return test_crc32c(void) { uint32_t crc_hw, crc_sw; char buffer[256]; for (int x = 0; x < 256; x++) buffer[x] = x; /* Compare hardware to software implementation */ crc_hw = crc32c(0, buffer, 256); crc_sw = crc32c_sw(0, buffer, 256); assert(crc_hw == 0x9c44184b); assert(crc_sw == 0x9c44184b); /* Test that passing a CRC in also works */ crc_hw = crc32c(crc_hw, buffer, 256); crc_sw = crc32c_sw(crc_sw, buffer, 256); assert(crc_hw == 0xae10ee5a); assert(crc_sw == 0xae10ee5a); /* Test odd offsets/sizes */ crc_hw = crc32c(crc_hw, buffer + 1, 256 - 2); crc_sw = crc32c_sw(crc_sw, buffer + 1, 256 - 2); assert(crc_hw == 0xed37b906); assert(crc_sw == 0xed37b906); return TEST_PASS; } static enum test_return test_issue_102(void) { char buffer[4096]; memset(buffer, ' ', sizeof(buffer)); buffer[sizeof(buffer) - 1] = '\0'; close_conn(); con = connect_server("127.0.0.1", port, false, enable_ssl); assert(con); send_ascii_command(buffer); /* verify that the server closed the connection */ assert(con->read(con, buffer, sizeof(buffer)) == 0); close_conn(); con = connect_server("127.0.0.1", port, false, enable_ssl); assert(con); snprintf(buffer, sizeof(buffer), "gets "); size_t offset = 5; while (offset < 4000) { offset += snprintf(buffer + offset, sizeof(buffer) - offset, "%010u ", (unsigned int)offset); } send_ascii_command(buffer); usleep(250); send_ascii_command("\r\n"); char rsp[80]; read_ascii_response(rsp, sizeof(rsp)); assert(strncmp(rsp, "END", strlen("END")) == 0); buffer[3]= ' '; send_ascii_command(buffer); usleep(250); send_ascii_command("\r\n"); read_ascii_response(rsp, sizeof(rsp)); assert(strncmp(rsp, "END", strlen("END")) == 0); memset(buffer, ' ', sizeof(buffer)); int len = snprintf(buffer + 101, sizeof(buffer) - 101, "gets foo"); buffer[101 + len] = ' '; buffer[sizeof(buffer) - 1] = '\0'; send_ascii_command(buffer); /* verify that the server closed the connection */ assert(con->read(con, buffer, sizeof(buffer)) == 0); close_conn(); con = connect_server("127.0.0.1", port, false, enable_ssl); assert(con); return TEST_PASS; } static enum test_return start_memcached_server(void) { server_pid = start_server(&port, false, 600); close_conn(); con = connect_server("127.0.0.1", port, false, enable_ssl); assert(con); return TEST_PASS; } static enum test_return stop_memcached_server(void) { close_conn(); if (server_pid != -1) { assert(kill(server_pid, SIGTERM) == 0); } return TEST_PASS; } static enum test_return shutdown_memcached_server(void) { char buffer[1024]; close_conn(); con = connect_server("127.0.0.1", port, false, enable_ssl); assert(con); send_ascii_command("shutdown\r\n"); /* verify that the server closed the connection */ assert(con->read(con, buffer, sizeof(buffer)) == 0); close_conn(); /* We set server_pid to -1 so that we don't later call kill() */ if (kill(server_pid, 0) == 0) { server_pid = -1; } return TEST_PASS; } static void safe_send(const void* buf, size_t len, bool hickup) { off_t offset = 0; const char* ptr = buf; #ifdef MESSAGE_DEBUG uint8_t val = *ptr; assert(val == (uint8_t)0x80); fprintf(stderr, "About to send %lu bytes:", (unsigned long)len); for (int ii = 0; ii < len; ++ii) { if (ii % 4 == 0) { fprintf(stderr, "\n "); } val = *(ptr + ii); fprintf(stderr, " 0x%02x", val); } fprintf(stderr, "\n"); usleep(500); #endif do { size_t num_bytes = len - offset; if (hickup) { if (num_bytes > 1024) { num_bytes = (rand() % 1023) + 1; } } ssize_t nw = con->write(con, ptr + offset, num_bytes); if (nw == -1) { if (errno != EINTR) { fprintf(stderr, "Failed to write: %s\n", strerror(errno)); abort(); } } else { if (hickup) { usleep(100); } offset += nw; } } while (offset < len); } static bool safe_recv(void *buf, size_t len) { if (len == 0) { return true; } off_t offset = 0; do { ssize_t nr = con->read(con, ((char*)buf) + offset, len - offset); if (nr == -1) { if (errno != EINTR) { fprintf(stderr, "Failed to read: %s\n", strerror(errno)); abort(); } } else { if (nr == 0 && allow_closed_read) { return false; } assert(nr != 0); offset += nr; } } while (offset < len); return true; } static bool safe_recv_packet(void *buf, size_t size) { protocol_binary_response_no_extras *response = buf; assert(size > sizeof(*response)); if (!safe_recv(response, sizeof(*response))) { return false; } response->message.header.response.keylen = ntohs(response->message.header.response.keylen); response->message.header.response.status = ntohs(response->message.header.response.status); response->message.header.response.bodylen = ntohl(response->message.header.response.bodylen); size_t len = sizeof(*response); char *ptr = buf; ptr += len; if (!safe_recv(ptr, response->message.header.response.bodylen)) { return false; } #ifdef MESSAGE_DEBUG usleep(500); ptr = buf; len += response->message.header.response.bodylen; uint8_t val = *ptr; assert(val == (uint8_t)0x81); fprintf(stderr, "Received %lu bytes:", (unsigned long)len); for (int ii = 0; ii < len; ++ii) { if (ii % 4 == 0) { fprintf(stderr, "\n "); } val = *(ptr + ii); fprintf(stderr, " 0x%02x", val); } fprintf(stderr, "\n"); #endif return true; } static off_t storage_command(char*buf, size_t bufsz, uint8_t cmd, const void* key, size_t keylen, const void* dta, size_t dtalen, uint32_t flags, uint32_t exp) { /* all of the storage commands use the same command layout */ protocol_binary_request_set *request = (void*)buf; assert(bufsz > sizeof(*request) + keylen + dtalen); memset(request, 0, sizeof(*request)); request->message.header.request.magic = PROTOCOL_BINARY_REQ; request->message.header.request.opcode = cmd; request->message.header.request.keylen = htons(keylen); request->message.header.request.extlen = 8; request->message.header.request.bodylen = htonl(keylen + 8 + dtalen); request->message.header.request.opaque = 0xdeadbeef; request->message.body.flags = flags; request->message.body.expiration = exp; off_t key_offset = sizeof(protocol_binary_request_no_extras) + 8; memcpy(buf + key_offset, key, keylen); if (dta != NULL) { memcpy(buf + key_offset + keylen, dta, dtalen); } return key_offset + keylen + dtalen; } static off_t ext_command(char* buf, size_t bufsz, uint8_t cmd, const void* ext, size_t extlen, const void* key, size_t keylen, const void* dta, size_t dtalen) { protocol_binary_request_no_extras *request = (void*)buf; assert(bufsz > sizeof(*request) + extlen + keylen + dtalen); memset(request, 0, sizeof(*request)); request->message.header.request.magic = PROTOCOL_BINARY_REQ; request->message.header.request.opcode = cmd; request->message.header.request.extlen = extlen; request->message.header.request.keylen = htons(keylen); request->message.header.request.bodylen = htonl(extlen + keylen + dtalen); request->message.header.request.opaque = 0xdeadbeef; off_t ext_offset = sizeof(protocol_binary_request_no_extras); off_t key_offset = ext_offset + extlen; off_t dta_offset = key_offset + keylen; if (ext != NULL) { memcpy(buf + ext_offset, ext, extlen); } if (key != NULL) { memcpy(buf + key_offset, key, keylen); } if (dta != NULL) { memcpy(buf + dta_offset, dta, dtalen); } return sizeof(*request) + extlen + keylen + dtalen; } static off_t raw_command(char* buf, size_t bufsz, uint8_t cmd, const void* key, size_t keylen, const void* dta, size_t dtalen) { /* all of the storage commands use the same command layout */ return ext_command(buf, bufsz, cmd, NULL, 0, key, keylen, dta, dtalen); } static off_t flush_command(char* buf, size_t bufsz, uint8_t cmd, uint32_t exptime, bool use_extra) { protocol_binary_request_flush *request = (void*)buf; assert(bufsz > sizeof(*request)); memset(request, 0, sizeof(*request)); request->message.header.request.magic = PROTOCOL_BINARY_REQ; request->message.header.request.opcode = cmd; off_t size = sizeof(protocol_binary_request_no_extras); if (use_extra) { request->message.header.request.extlen = 4; request->message.body.expiration = htonl(exptime); request->message.header.request.bodylen = htonl(4); size += 4; } request->message.header.request.opaque = 0xdeadbeef; return size; } static off_t touch_command(char* buf, size_t bufsz, uint8_t cmd, const void* key, size_t keylen, uint32_t exptime) { protocol_binary_request_touch *request = (void*)buf; assert(bufsz > sizeof(*request)); memset(request, 0, sizeof(*request)); request->message.header.request.magic = PROTOCOL_BINARY_REQ; request->message.header.request.opcode = cmd; request->message.header.request.keylen = htons(keylen); request->message.header.request.extlen = 4; request->message.body.expiration = htonl(exptime); request->message.header.request.bodylen = htonl(keylen + 4); request->message.header.request.opaque = 0xdeadbeef; off_t key_offset = sizeof(protocol_binary_request_no_extras) + 4; memcpy(buf + key_offset, key, keylen); return sizeof(protocol_binary_request_no_extras) + 4 + keylen; } static off_t arithmetic_command(char* buf, size_t bufsz, uint8_t cmd, const void* key, size_t keylen, uint64_t delta, uint64_t initial, uint32_t exp) { protocol_binary_request_incr *request = (void*)buf; assert(bufsz > sizeof(*request) + keylen); memset(request, 0, sizeof(*request)); request->message.header.request.magic = PROTOCOL_BINARY_REQ; request->message.header.request.opcode = cmd; request->message.header.request.keylen = htons(keylen); request->message.header.request.extlen = 20; request->message.header.request.bodylen = htonl(keylen + 20); request->message.header.request.opaque = 0xdeadbeef; request->message.body.delta = htonll(delta); request->message.body.initial = htonll(initial); request->message.body.expiration = htonl(exp); off_t key_offset = sizeof(protocol_binary_request_no_extras) + 20; memcpy(buf + key_offset, key, keylen); return key_offset + keylen; } static void validate_response_header(protocol_binary_response_no_extras *response, uint8_t cmd, uint16_t status) { assert(response->message.header.response.magic == PROTOCOL_BINARY_RES); assert(response->message.header.response.opcode == cmd); assert(response->message.header.response.datatype == PROTOCOL_BINARY_RAW_BYTES); assert(response->message.header.response.status == status); assert(response->message.header.response.opaque == 0xdeadbeef); if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) { switch (cmd) { case PROTOCOL_BINARY_CMD_ADDQ: case PROTOCOL_BINARY_CMD_APPENDQ: case PROTOCOL_BINARY_CMD_DECREMENTQ: case PROTOCOL_BINARY_CMD_DELETEQ: case PROTOCOL_BINARY_CMD_FLUSHQ: case PROTOCOL_BINARY_CMD_INCREMENTQ: case PROTOCOL_BINARY_CMD_PREPENDQ: case PROTOCOL_BINARY_CMD_QUITQ: case PROTOCOL_BINARY_CMD_REPLACEQ: case PROTOCOL_BINARY_CMD_SETQ: assert("Quiet command shouldn't return on success" == NULL); default: break; } switch (cmd) { case PROTOCOL_BINARY_CMD_ADD: case PROTOCOL_BINARY_CMD_REPLACE: case PROTOCOL_BINARY_CMD_SET: case PROTOCOL_BINARY_CMD_APPEND: case PROTOCOL_BINARY_CMD_PREPEND: assert(response->message.header.response.keylen == 0); assert(response->message.header.response.extlen == 0); assert(response->message.header.response.bodylen == 0); assert(response->message.header.response.cas != 0); break; case PROTOCOL_BINARY_CMD_FLUSH: case PROTOCOL_BINARY_CMD_NOOP: case PROTOCOL_BINARY_CMD_QUIT: case PROTOCOL_BINARY_CMD_DELETE: assert(response->message.header.response.keylen == 0); assert(response->message.header.response.extlen == 0); assert(response->message.header.response.bodylen == 0); assert(response->message.header.response.cas == 0); break; case PROTOCOL_BINARY_CMD_DECREMENT: case PROTOCOL_BINARY_CMD_INCREMENT: assert(response->message.header.response.keylen == 0); assert(response->message.header.response.extlen == 0); assert(response->message.header.response.bodylen == 8); assert(response->message.header.response.cas != 0); break; case PROTOCOL_BINARY_CMD_STAT: assert(response->message.header.response.extlen == 0); /* key and value exists in all packets except in the terminating */ assert(response->message.header.response.cas == 0); break; case PROTOCOL_BINARY_CMD_VERSION: assert(response->message.header.response.keylen == 0); assert(response->message.header.response.extlen == 0); assert(response->message.header.response.bodylen != 0); assert(response->message.header.response.cas == 0); break; case PROTOCOL_BINARY_CMD_GET: case PROTOCOL_BINARY_CMD_GETQ: case PROTOCOL_BINARY_CMD_GAT: case PROTOCOL_BINARY_CMD_GATQ: assert(response->message.header.response.keylen == 0); assert(response->message.header.response.extlen == 4); assert(response->message.header.response.cas != 0); break; case PROTOCOL_BINARY_CMD_GETK: case PROTOCOL_BINARY_CMD_GETKQ: case PROTOCOL_BINARY_CMD_GATK: case PROTOCOL_BINARY_CMD_GATKQ: assert(response->message.header.response.keylen != 0); assert(response->message.header.response.extlen == 4); assert(response->message.header.response.cas != 0); break; default: /* Undefined command code */ break; } } else { assert(response->message.header.response.cas == 0); assert(response->message.header.response.extlen == 0); if (cmd != PROTOCOL_BINARY_CMD_GETK && cmd != PROTOCOL_BINARY_CMD_GATK) { assert(response->message.header.response.keylen == 0); } } } static enum test_return test_binary_noop(void) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } buffer; size_t len = raw_command(buffer.bytes, sizeof(buffer.bytes), PROTOCOL_BINARY_CMD_NOOP, NULL, 0, NULL, 0); safe_send(buffer.bytes, len, false); safe_recv_packet(buffer.bytes, sizeof(buffer.bytes)); validate_response_header(&buffer.response, PROTOCOL_BINARY_CMD_NOOP, PROTOCOL_BINARY_RESPONSE_SUCCESS); return TEST_PASS; } static enum test_return test_binary_quit_impl(uint8_t cmd) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } buffer; size_t len = raw_command(buffer.bytes, sizeof(buffer.bytes), cmd, NULL, 0, NULL, 0); safe_send(buffer.bytes, len, false); if (cmd == PROTOCOL_BINARY_CMD_QUIT) { safe_recv_packet(buffer.bytes, sizeof(buffer.bytes)); validate_response_header(&buffer.response, PROTOCOL_BINARY_CMD_QUIT, PROTOCOL_BINARY_RESPONSE_SUCCESS); } /* Socket should be closed now, read should return 0 */ assert(con->read(con, buffer.bytes, sizeof(buffer.bytes)) == 0); close_conn(); con = connect_server("127.0.0.1", port, false, enable_ssl); assert(con); return TEST_PASS; } static enum test_return test_binary_quit(void) { return test_binary_quit_impl(PROTOCOL_BINARY_CMD_QUIT); } static enum test_return test_binary_quitq(void) { return test_binary_quit_impl(PROTOCOL_BINARY_CMD_QUITQ); } static enum test_return test_binary_set_impl(const char *key, uint8_t cmd) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } send, receive; uint64_t value = 0xdeadbeefdeadcafe; size_t len = storage_command(send.bytes, sizeof(send.bytes), cmd, key, strlen(key), &value, sizeof(value), 0, 0); /* Set should work over and over again */ int ii; for (ii = 0; ii < 10; ++ii) { safe_send(send.bytes, len, false); if (cmd == PROTOCOL_BINARY_CMD_SET) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS); } } if (cmd == PROTOCOL_BINARY_CMD_SETQ) { return test_binary_noop(); } send.request.message.header.request.cas = receive.response.message.header.response.cas; safe_send(send.bytes, len, false); if (cmd == PROTOCOL_BINARY_CMD_SET) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS); assert(receive.response.message.header.response.cas != send.request.message.header.request.cas); } else { return test_binary_noop(); } return TEST_PASS; } static enum test_return test_binary_set(void) { return test_binary_set_impl("test_binary_set", PROTOCOL_BINARY_CMD_SET); } static enum test_return test_binary_setq(void) { return test_binary_set_impl("test_binary_setq", PROTOCOL_BINARY_CMD_SETQ); } static enum test_return test_binary_add_impl(const char *key, uint8_t cmd) { uint64_t value = 0xdeadbeefdeadcafe; union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } send, receive; size_t len = storage_command(send.bytes, sizeof(send.bytes), cmd, key, strlen(key), &value, sizeof(value), 0, 0); /* Add should only work the first time */ int ii; for (ii = 0; ii < 10; ++ii) { safe_send(send.bytes, len, false); if (ii == 0) { if (cmd == PROTOCOL_BINARY_CMD_ADD) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS); } } else { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS); } } return TEST_PASS; } static enum test_return test_binary_add(void) { return test_binary_add_impl("test_binary_add", PROTOCOL_BINARY_CMD_ADD); } static enum test_return test_binary_addq(void) { return test_binary_add_impl("test_binary_addq", PROTOCOL_BINARY_CMD_ADDQ); } static enum test_return test_binary_replace_impl(const char* key, uint8_t cmd) { uint64_t value = 0xdeadbeefdeadcafe; union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } send, receive; size_t len = storage_command(send.bytes, sizeof(send.bytes), cmd, key, strlen(key), &value, sizeof(value), 0, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT); len = storage_command(send.bytes, sizeof(send.bytes), PROTOCOL_BINARY_CMD_ADD, key, strlen(key), &value, sizeof(value), 0, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_ADD, PROTOCOL_BINARY_RESPONSE_SUCCESS); len = storage_command(send.bytes, sizeof(send.bytes), cmd, key, strlen(key), &value, sizeof(value), 0, 0); int ii; for (ii = 0; ii < 10; ++ii) { safe_send(send.bytes, len, false); if (cmd == PROTOCOL_BINARY_CMD_REPLACE) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_REPLACE, PROTOCOL_BINARY_RESPONSE_SUCCESS); } } if (cmd == PROTOCOL_BINARY_CMD_REPLACEQ) { test_binary_noop(); } return TEST_PASS; } static enum test_return test_binary_replace(void) { return test_binary_replace_impl("test_binary_replace", PROTOCOL_BINARY_CMD_REPLACE); } static enum test_return test_binary_replaceq(void) { return test_binary_replace_impl("test_binary_replaceq", PROTOCOL_BINARY_CMD_REPLACEQ); } static enum test_return test_binary_delete_impl(const char *key, uint8_t cmd) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } send, receive; size_t len = raw_command(send.bytes, sizeof(send.bytes), cmd, key, strlen(key), NULL, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT); len = storage_command(send.bytes, sizeof(send.bytes), PROTOCOL_BINARY_CMD_ADD, key, strlen(key), NULL, 0, 0, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_ADD, PROTOCOL_BINARY_RESPONSE_SUCCESS); len = raw_command(send.bytes, sizeof(send.bytes), cmd, key, strlen(key), NULL, 0); safe_send(send.bytes, len, false); if (cmd == PROTOCOL_BINARY_CMD_DELETE) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_DELETE, PROTOCOL_BINARY_RESPONSE_SUCCESS); } safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT); return TEST_PASS; } static enum test_return test_binary_delete(void) { return test_binary_delete_impl("test_binary_delete", PROTOCOL_BINARY_CMD_DELETE); } static enum test_return test_binary_deleteq(void) { return test_binary_delete_impl("test_binary_deleteq", PROTOCOL_BINARY_CMD_DELETEQ); } static enum test_return test_binary_get_impl(const char *key, uint8_t cmd) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } send, receive; uint32_t expiration = htonl(3600); size_t extlen = 0; if (cmd == PROTOCOL_BINARY_CMD_GAT || cmd == PROTOCOL_BINARY_CMD_GATK) extlen = sizeof(expiration); size_t len = ext_command(send.bytes, sizeof(send.bytes), cmd, extlen ? &expiration : NULL, extlen, key, strlen(key), NULL, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT); len = storage_command(send.bytes, sizeof(send.bytes), PROTOCOL_BINARY_CMD_ADD, key, strlen(key), NULL, 0, 0, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_ADD, PROTOCOL_BINARY_RESPONSE_SUCCESS); /* run a little pipeline test ;-) */ len = 0; int ii; for (ii = 0; ii < 10; ++ii) { union { protocol_binary_request_no_extras request; char bytes[1024]; } temp; size_t l = ext_command(temp.bytes, sizeof(temp.bytes), cmd, extlen ? &expiration : NULL, extlen, key, strlen(key), NULL, 0); memcpy(send.bytes + len, temp.bytes, l); len += l; } safe_send(send.bytes, len, false); for (ii = 0; ii < 10; ++ii) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS); } return TEST_PASS; } static enum test_return test_binary_get(void) { return test_binary_get_impl("test_binary_get", PROTOCOL_BINARY_CMD_GET); } static enum test_return test_binary_getk(void) { return test_binary_get_impl("test_binary_getk", PROTOCOL_BINARY_CMD_GETK); } static enum test_return test_binary_gat(void) { return test_binary_get_impl("test_binary_gat", PROTOCOL_BINARY_CMD_GAT); } static enum test_return test_binary_gatk(void) { return test_binary_get_impl("test_binary_gatk", PROTOCOL_BINARY_CMD_GATK); } static enum test_return test_binary_getq_impl(const char *key, uint8_t cmd) { const char *missing = "test_binary_getq_missing"; union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } send, temp, receive; uint32_t expiration = htonl(3600); size_t extlen = 0; if (cmd == PROTOCOL_BINARY_CMD_GATQ || cmd == PROTOCOL_BINARY_CMD_GATKQ) extlen = sizeof(expiration); size_t len = storage_command(send.bytes, sizeof(send.bytes), PROTOCOL_BINARY_CMD_ADD, key, strlen(key), NULL, 0, 0, 0); size_t len2 = ext_command(temp.bytes, sizeof(temp.bytes), cmd, extlen ? &expiration : NULL, extlen, missing, strlen(missing), NULL, 0); /* I need to change the first opaque so that I can separate the two * return packets */ temp.request.message.header.request.opaque = 0xfeedface; memcpy(send.bytes + len, temp.bytes, len2); len += len2; len2 = ext_command(temp.bytes, sizeof(temp.bytes), cmd, extlen ? &expiration : NULL, extlen, key, strlen(key), NULL, 0); memcpy(send.bytes + len, temp.bytes, len2); len += len2; safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_ADD, PROTOCOL_BINARY_RESPONSE_SUCCESS); /* The first GETQ shouldn't return anything */ safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS); return TEST_PASS; } static enum test_return test_binary_getq(void) { return test_binary_getq_impl("test_binary_getq", PROTOCOL_BINARY_CMD_GETQ); } static enum test_return test_binary_getkq(void) { return test_binary_getq_impl("test_binary_getkq", PROTOCOL_BINARY_CMD_GETKQ); } static enum test_return test_binary_gatq(void) { return test_binary_getq_impl("test_binary_gatq", PROTOCOL_BINARY_CMD_GATQ); } static enum test_return test_binary_gatkq(void) { return test_binary_getq_impl("test_binary_gatkq", PROTOCOL_BINARY_CMD_GATKQ); } static enum test_return test_binary_incr_impl(const char* key, uint8_t cmd) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response_header; protocol_binary_response_incr response; char bytes[1024]; } send, receive; size_t len = arithmetic_command(send.bytes, sizeof(send.bytes), cmd, key, strlen(key), 1, 0, 0); int ii; for (ii = 0; ii < 10; ++ii) { safe_send(send.bytes, len, false); if (cmd == PROTOCOL_BINARY_CMD_INCREMENT) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response_header, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS); assert(ntohll(receive.response.message.body.value) == ii); } } if (cmd == PROTOCOL_BINARY_CMD_INCREMENTQ) { test_binary_noop(); } return TEST_PASS; } static enum test_return test_binary_incr(void) { return test_binary_incr_impl("test_binary_incr", PROTOCOL_BINARY_CMD_INCREMENT); } static enum test_return test_binary_incrq(void) { return test_binary_incr_impl("test_binary_incrq", PROTOCOL_BINARY_CMD_INCREMENTQ); } static enum test_return test_binary_decr_impl(const char* key, uint8_t cmd) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response_header; protocol_binary_response_decr response; char bytes[1024]; } send, receive; size_t len = arithmetic_command(send.bytes, sizeof(send.bytes), cmd, key, strlen(key), 1, 9, 0); int ii; for (ii = 9; ii >= 0; --ii) { safe_send(send.bytes, len, false); if (cmd == PROTOCOL_BINARY_CMD_DECREMENT) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response_header, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS); assert(ntohll(receive.response.message.body.value) == ii); } } /* decr on 0 should not wrap */ safe_send(send.bytes, len, false); if (cmd == PROTOCOL_BINARY_CMD_DECREMENT) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response_header, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS); assert(ntohll(receive.response.message.body.value) == 0); } else { test_binary_noop(); } return TEST_PASS; } static enum test_return test_binary_decr(void) { return test_binary_decr_impl("test_binary_decr", PROTOCOL_BINARY_CMD_DECREMENT); } static enum test_return test_binary_decrq(void) { return test_binary_decr_impl("test_binary_decrq", PROTOCOL_BINARY_CMD_DECREMENTQ); } static enum test_return test_binary_version(void) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } buffer; size_t len = raw_command(buffer.bytes, sizeof(buffer.bytes), PROTOCOL_BINARY_CMD_VERSION, NULL, 0, NULL, 0); safe_send(buffer.bytes, len, false); safe_recv_packet(buffer.bytes, sizeof(buffer.bytes)); validate_response_header(&buffer.response, PROTOCOL_BINARY_CMD_VERSION, PROTOCOL_BINARY_RESPONSE_SUCCESS); return TEST_PASS; } static enum test_return test_binary_flush_impl(const char *key, uint8_t cmd) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } send, receive; size_t len = storage_command(send.bytes, sizeof(send.bytes), PROTOCOL_BINARY_CMD_ADD, key, strlen(key), NULL, 0, 0, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_ADD, PROTOCOL_BINARY_RESPONSE_SUCCESS); len = flush_command(send.bytes, sizeof(send.bytes), cmd, 2, true); safe_send(send.bytes, len, false); if (cmd == PROTOCOL_BINARY_CMD_FLUSH) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS); } len = raw_command(send.bytes, sizeof(send.bytes), PROTOCOL_BINARY_CMD_GET, key, strlen(key), NULL, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_GET, PROTOCOL_BINARY_RESPONSE_SUCCESS); sleep(2); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_GET, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT); int ii; for (ii = 0; ii < 2; ++ii) { len = storage_command(send.bytes, sizeof(send.bytes), PROTOCOL_BINARY_CMD_ADD, key, strlen(key), NULL, 0, 0, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_ADD, PROTOCOL_BINARY_RESPONSE_SUCCESS); len = flush_command(send.bytes, sizeof(send.bytes), cmd, 0, ii == 0); safe_send(send.bytes, len, false); if (cmd == PROTOCOL_BINARY_CMD_FLUSH) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS); } len = raw_command(send.bytes, sizeof(send.bytes), PROTOCOL_BINARY_CMD_GET, key, strlen(key), NULL, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_GET, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT); } return TEST_PASS; } static enum test_return test_binary_flush(void) { return test_binary_flush_impl("test_binary_flush", PROTOCOL_BINARY_CMD_FLUSH); } static enum test_return test_binary_flushq(void) { return test_binary_flush_impl("test_binary_flushq", PROTOCOL_BINARY_CMD_FLUSHQ); } static enum test_return test_binary_concat_impl(const char *key, uint8_t cmd) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } send, receive; const char *value = "world"; size_t len = raw_command(send.bytes, sizeof(send.bytes), cmd, key, strlen(key), value, strlen(value)); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_NOT_STORED); len = storage_command(send.bytes, sizeof(send.bytes), PROTOCOL_BINARY_CMD_ADD, key, strlen(key), value, strlen(value), 0, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_ADD, PROTOCOL_BINARY_RESPONSE_SUCCESS); len = raw_command(send.bytes, sizeof(send.bytes), cmd, key, strlen(key), value, strlen(value)); safe_send(send.bytes, len, false); if (cmd == PROTOCOL_BINARY_CMD_APPEND || cmd == PROTOCOL_BINARY_CMD_PREPEND) { safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS); } else { len = raw_command(send.bytes, sizeof(send.bytes), PROTOCOL_BINARY_CMD_NOOP, NULL, 0, NULL, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_NOOP, PROTOCOL_BINARY_RESPONSE_SUCCESS); } len = raw_command(send.bytes, sizeof(send.bytes), PROTOCOL_BINARY_CMD_GETK, key, strlen(key), NULL, 0); safe_send(send.bytes, len, false); safe_recv_packet(receive.bytes, sizeof(receive.bytes)); validate_response_header(&receive.response, PROTOCOL_BINARY_CMD_GETK, PROTOCOL_BINARY_RESPONSE_SUCCESS); assert(receive.response.message.header.response.keylen == strlen(key)); assert(receive.response.message.header.response.bodylen == (strlen(key) + 2*strlen(value) + 4)); char *ptr = receive.bytes; ptr += sizeof(receive.response); ptr += 4; assert(memcmp(ptr, key, strlen(key)) == 0); ptr += strlen(key); assert(memcmp(ptr, value, strlen(value)) == 0); ptr += strlen(value); assert(memcmp(ptr, value, strlen(value)) == 0); return TEST_PASS; } static enum test_return test_binary_append(void) { return test_binary_concat_impl("test_binary_append", PROTOCOL_BINARY_CMD_APPEND); } static enum test_return test_binary_prepend(void) { return test_binary_concat_impl("test_binary_prepend", PROTOCOL_BINARY_CMD_PREPEND); } static enum test_return test_binary_appendq(void) { return test_binary_concat_impl("test_binary_appendq", PROTOCOL_BINARY_CMD_APPENDQ); } static enum test_return test_binary_prependq(void) { return test_binary_concat_impl("test_binary_prependq", PROTOCOL_BINARY_CMD_PREPENDQ); } static enum test_return test_binary_stat(void) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } buffer; size_t len = raw_command(buffer.bytes, sizeof(buffer.bytes), PROTOCOL_BINARY_CMD_STAT, NULL, 0, NULL, 0); safe_send(buffer.bytes, len, false); do { safe_recv_packet(buffer.bytes, sizeof(buffer.bytes)); validate_response_header(&buffer.response, PROTOCOL_BINARY_CMD_STAT, PROTOCOL_BINARY_RESPONSE_SUCCESS); } while (buffer.response.message.header.response.keylen != 0); return TEST_PASS; } static enum test_return test_binary_illegal(void) { uint8_t cmd = 0x25; while (cmd != 0x00) { union { protocol_binary_request_no_extras request; protocol_binary_response_no_extras response; char bytes[1024]; } buffer; size_t len = raw_command(buffer.bytes, sizeof(buffer.bytes), cmd, NULL, 0, NULL, 0); safe_send(buffer.bytes, len, false); safe_recv_packet(buffer.bytes, sizeof(buffer.bytes)); validate_response_header(&buffer.response, cmd, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND); ++cmd; } return TEST_PASS; } volatile bool hickup_thread_running; static void *binary_hickup_recv_verification_thread(void *arg) { protocol_binary_response_no_extras *response = malloc(65*1024); if (response != NULL) { while (safe_recv_packet(response, 65*1024)) { /* Just validate the packet format */ validate_response_header(response, response->message.header.response.opcode, response->message.header.response.status); } free(response); } hickup_thread_running = false; allow_closed_read = false; return NULL; } static enum test_return test_binary_pipeline_hickup_chunk(void *buffer, size_t buffersize) { off_t offset = 0; char *key[256] = { NULL }; uint64_t value = 0xfeedfacedeadbeef; while (hickup_thread_running && offset + sizeof(protocol_binary_request_no_extras) < buffersize) { union { protocol_binary_request_no_extras request; char bytes[65 * 1024]; } command; uint8_t cmd = (uint8_t)(rand() & 0xff); size_t len; size_t keylen = (rand() % 250) + 1; switch (cmd) { case PROTOCOL_BINARY_CMD_ADD: case PROTOCOL_BINARY_CMD_ADDQ: case PROTOCOL_BINARY_CMD_REPLACE: case PROTOCOL_BINARY_CMD_REPLACEQ: case PROTOCOL_BINARY_CMD_SET: case PROTOCOL_BINARY_CMD_SETQ: len = storage_command(command.bytes, sizeof(command.bytes), cmd, key, keylen , &value, sizeof(value), 0, 0); break; case PROTOCOL_BINARY_CMD_APPEND: case PROTOCOL_BINARY_CMD_APPENDQ: case PROTOCOL_BINARY_CMD_PREPEND: case PROTOCOL_BINARY_CMD_PREPENDQ: len = raw_command(command.bytes, sizeof(command.bytes), cmd, key, keylen, &value, sizeof(value)); break; case PROTOCOL_BINARY_CMD_FLUSH: case PROTOCOL_BINARY_CMD_FLUSHQ: len = raw_command(command.bytes, sizeof(command.bytes), cmd, NULL, 0, NULL, 0); break; case PROTOCOL_BINARY_CMD_NOOP: len = raw_command(command.bytes, sizeof(command.bytes), cmd, NULL, 0, NULL, 0); break; case PROTOCOL_BINARY_CMD_DELETE: case PROTOCOL_BINARY_CMD_DELETEQ: len = raw_command(command.bytes, sizeof(command.bytes), cmd, key, keylen, NULL, 0); break; case PROTOCOL_BINARY_CMD_DECREMENT: case PROTOCOL_BINARY_CMD_DECREMENTQ: case PROTOCOL_BINARY_CMD_INCREMENT: case PROTOCOL_BINARY_CMD_INCREMENTQ: len = arithmetic_command(command.bytes, sizeof(command.bytes), cmd, key, keylen, 1, 0, 0); break; case PROTOCOL_BINARY_CMD_VERSION: len = raw_command(command.bytes, sizeof(command.bytes), PROTOCOL_BINARY_CMD_VERSION, NULL, 0, NULL, 0); break; case PROTOCOL_BINARY_CMD_GET: case PROTOCOL_BINARY_CMD_GETK: case PROTOCOL_BINARY_CMD_GETKQ: case PROTOCOL_BINARY_CMD_GETQ: len = raw_command(command.bytes, sizeof(command.bytes), cmd, key, keylen, NULL, 0); break; case PROTOCOL_BINARY_CMD_TOUCH: case PROTOCOL_BINARY_CMD_GAT: case PROTOCOL_BINARY_CMD_GATQ: case PROTOCOL_BINARY_CMD_GATK: case PROTOCOL_BINARY_CMD_GATKQ: len = touch_command(command.bytes, sizeof(command.bytes), cmd, key, keylen, 10); break; case PROTOCOL_BINARY_CMD_STAT: len = raw_command(command.bytes, sizeof(command.bytes), PROTOCOL_BINARY_CMD_STAT, NULL, 0, NULL, 0); break; case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS: case PROTOCOL_BINARY_CMD_SASL_AUTH: case PROTOCOL_BINARY_CMD_SASL_STEP: /* Ignoring SASL */ case PROTOCOL_BINARY_CMD_QUITQ: case PROTOCOL_BINARY_CMD_QUIT: /* I don't want to pass on the quit commands ;-) */ cmd |= 0xf0; /* FALLTHROUGH */ default: len = raw_command(command.bytes, sizeof(command.bytes), cmd, NULL, 0, NULL, 0); } if ((len + offset) < buffersize) { memcpy(((char*)buffer) + offset, command.bytes, len); offset += len; } else { break; } } safe_send(buffer, offset, true); return TEST_PASS; } static enum test_return test_binary_pipeline_hickup(void) { size_t buffersize = 65 * 1024; void *buffer = malloc(buffersize); int ii; pthread_t tid; int ret; allow_closed_read = true; hickup_thread_running = true; if ((ret = pthread_create(&tid, NULL, binary_hickup_recv_verification_thread, NULL)) != 0) { fprintf(stderr, "Can't create thread: %s\n", strerror(ret)); free(buffer); return TEST_FAIL; } /* Allow the thread to start */ usleep(250); srand((int)time(NULL)); for (ii = 0; ii < 2; ++ii) { test_binary_pipeline_hickup_chunk(buffer, buffersize); } /* send quitq to shut down the read thread ;-) */ size_t len = raw_command(buffer, buffersize, PROTOCOL_BINARY_CMD_QUITQ, NULL, 0, NULL, 0); safe_send(buffer, len, false); pthread_join(tid, NULL); free(buffer); return TEST_PASS; } static enum test_return test_issue_101(void) { enum { max = 2 }; enum test_return ret = TEST_PASS; struct conn *conns[max]; int ii = 0; pid_t child = 0; if (getenv("SKIP_TEST_101") != NULL) { return TEST_SKIP; } const char *command = "stats\r\nstats\r\nstats\r\nstats\r\nstats\r\n"; size_t cmdlen = strlen(command); server_pid = start_server(&port, false, 1000); for (ii = 0; ii < max; ++ii) { conns[ii] = NULL; conns[ii] = connect_server("127.0.0.1", port, true, enable_ssl); assert(conns[ii]); assert(conns[ii]->sock > 0); } /* Send command on the connection until it blocks */ for (ii = 0; ii < max; ++ii) { bool more = true; do { ssize_t err = conns[ii]->write(conns[ii], command, cmdlen); if (err == -1) { switch (errno) { case EINTR: break; case ENOMEM: case EWOULDBLOCK: more = false; break; default: ret = TEST_FAIL; goto cleanup; } } } while (more); } child = fork(); if (child == (pid_t)-1) { abort(); } else if (child > 0) { int stat; pid_t c; while ((c = waitpid(child, &stat, 0)) == (pid_t)-1 && errno == EINTR); assert(c == child); assert(stat == 0); } else { con = connect_server("127.0.0.1", port, false, enable_ssl); assert(con); ret = test_binary_noop(); close_conn(); exit(0); } cleanup: /* close all connections */ for (ii = 0; ii < max; ++ii) { struct conn *c = conns[ii]; if (c == NULL) continue; #ifdef TLS if (c->ssl) { SSL_shutdown(c->ssl); SSL_free(c->ssl); } if (c->ssl_ctx) SSL_CTX_free(c->ssl_ctx); #endif if (c->sock > 0) close(c->sock); free(conns[ii]); conns[ii] = NULL; } assert(kill(server_pid, SIGTERM) == 0); return ret; } typedef enum test_return (*TEST_FUNC)(void); struct testcase { const char *description; TEST_FUNC function; }; struct testcase testcases[] = { { "cache_create", cache_create_test }, { "cache_reuse", cache_reuse_test }, { "cache_redzone", cache_redzone_test }, { "cache_limit_revised_downward", cache_limit_revised_downward_test }, { "stats_prefix_find", test_stats_prefix_find }, { "stats_prefix_record_get", test_stats_prefix_record_get }, { "stats_prefix_record_delete", test_stats_prefix_record_delete }, { "stats_prefix_record_set", test_stats_prefix_record_set }, { "stats_prefix_dump", test_stats_prefix_dump }, { "issue_161", test_issue_161 }, { "strtol", test_safe_strtol }, { "strtoll", test_safe_strtoll }, { "strtoul", test_safe_strtoul }, { "strtoull", test_safe_strtoull }, { "issue_44", test_issue_44 }, { "vperror", test_vperror }, { "issue_101", test_issue_101 }, { "crc32c", test_crc32c }, /* The following tests all run towards the same server */ { "start_server", start_memcached_server }, { "issue_92", test_issue_92 }, { "issue_102", test_issue_102 }, { "binary_noop", test_binary_noop }, { "binary_quit", test_binary_quit }, { "binary_quitq", test_binary_quitq }, { "binary_set", test_binary_set }, { "binary_setq", test_binary_setq }, { "binary_add", test_binary_add }, { "binary_addq", test_binary_addq }, { "binary_replace", test_binary_replace }, { "binary_replaceq", test_binary_replaceq }, { "binary_delete", test_binary_delete }, { "binary_deleteq", test_binary_deleteq }, { "binary_get", test_binary_get }, { "binary_getq", test_binary_getq }, { "binary_getk", test_binary_getk }, { "binary_getkq", test_binary_getkq }, { "binary_gat", test_binary_gat }, { "binary_gatq", test_binary_gatq }, { "binary_gatk", test_binary_gatk }, { "binary_gatkq", test_binary_gatkq }, { "binary_incr", test_binary_incr }, { "binary_incrq", test_binary_incrq }, { "binary_decr", test_binary_decr }, { "binary_decrq", test_binary_decrq }, { "binary_version", test_binary_version }, { "binary_flush", test_binary_flush }, { "binary_flushq", test_binary_flushq }, { "binary_append", test_binary_append }, { "binary_appendq", test_binary_appendq }, { "binary_prepend", test_binary_prepend }, { "binary_prependq", test_binary_prependq }, { "binary_stat", test_binary_stat }, { "binary_illegal", test_binary_illegal }, { "binary_pipeline_hickup", test_binary_pipeline_hickup }, { "shutdown", shutdown_memcached_server }, { "stop_server", stop_memcached_server }, { NULL, NULL } }; /* Stub out function defined in memcached.c */ void STATS_LOCK(void); void STATS_UNLOCK(void); void STATS_LOCK(void) {} void STATS_UNLOCK(void) {} int main(int argc, char **argv) { int exitcode = 0; int ii = 0, num_cases = 0; #ifdef TLS if (getenv("SSL_TEST") != NULL) { SSLeay_add_ssl_algorithms(); SSL_load_error_strings(); enable_ssl = true; } #endif /* Initialized directly instead of using hash_init to avoid pulling in the definition of settings struct from memcached.h */ hash = jenkins_hash; stats_prefix_init(':'); crc32c_init(); for (num_cases = 0; testcases[num_cases].description; num_cases++) { /* Just counting */ } printf("1..%d\n", num_cases); for (ii = 0; testcases[ii].description != NULL; ++ii) { fflush(stdout); #ifndef DEBUG /* the test program shouldn't run longer than 10 minutes... */ alarm(600); #endif enum test_return ret = testcases[ii].function(); if (ret == TEST_SKIP) { fprintf(stdout, "ok # SKIP %d - %s\n", ii + 1, testcases[ii].description); } else if (ret == TEST_PASS) { fprintf(stdout, "ok %d - %s\n", ii + 1, testcases[ii].description); } else { fprintf(stdout, "not ok %d - %s\n", ii + 1, testcases[ii].description); exitcode = 1; } fflush(stdout); } return exitcode; } memcached-1.6.20/darwin_priv.c0000664000175000017500000000131114357451302013121 00000000000000#include #include #include #include #include "memcached.h" #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" /* * the sandbox api is marked deprecated, however still used * by couple of major softwares/libraries like openssh */ void drop_privileges(void) { extern char *__progname; char *error = NULL; if (sandbox_init(kSBXProfileNoInternet, SANDBOX_NAMED, &error) < 0) { fprintf(stderr, "%s: sandbox_init: %s\n", __progname, error); sandbox_free_error(error); exit(EXIT_FAILURE); } } #pragma clang diagnostic pop void setup_privilege_violations_handler(void) { // not needed } memcached-1.6.20/crc32c.c0000664000175000017500000004264614427543277011707 00000000000000/* crc32c.c -- compute CRC-32C using the Intel crc32 instruction * Copyright (C) 2013, 2015 Mark Adler * Version 1.3 31 Dec 2015 Mark Adler */ /* This software is provided 'as-is', without any express or implied warranty. In no event will the author be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Mark Adler madler@alumni.caltech.edu */ /* Use hardware CRC instruction on Intel SSE 4.2 processors. This computes a CRC-32C, *not* the CRC-32 used by Ethernet and zip, gzip, etc. A software version is provided as a fall-back, as well as for speed comparisons. */ /* Version history: 1.0 10 Feb 2013 First version 1.1 1 Aug 2013 Correct comments on why three crc instructions in parallel 1.2 1 Nov 2015 Add const qualifier to avoid compiler warning Load entire input into memory (test code) Argument gives number of times to repeat (test code) Argument < 0 forces software implementation (test code) 1.3 31 Dec 2015 Check for Intel architecture using compiler macro Support big-endian processors in software calculation Add header for external use */ #include #include "crc32c.h" crc_func crc32c; /* CRC-32C (iSCSI) polynomial in reversed bit order. */ #define POLY 0x82f63b78 uint32_t crc32c_sw_little(uint32_t crc, void const *buf, size_t len); uint32_t crc32c_sw_big(uint32_t crc, void const *buf, size_t len); #ifdef __x86_64__ /* Hardware CRC-32C for Intel and compatible processors. */ /* Multiply a matrix times a vector over the Galois field of two elements, GF(2). Each element is a bit in an unsigned integer. mat must have at least as many entries as the power of two for most significant one bit in vec. */ static inline uint32_t gf2_matrix_times(uint32_t *mat, uint32_t vec) { uint32_t sum = 0; while (vec) { if (vec & 1) sum ^= *mat; vec >>= 1; mat++; } return sum; } /* Multiply a matrix by itself over GF(2). Both mat and square must have 32 rows. */ static inline void gf2_matrix_square(uint32_t *square, uint32_t *mat) { for (unsigned n = 0; n < 32; n++) square[n] = gf2_matrix_times(mat, mat[n]); } /* Construct an operator to apply len zeros to a crc. len must be a power of two. If len is not a power of two, then the result is the same as for the largest power of two less than len. The result for len == 0 is the same as for len == 1. A version of this routine could be easily written for any len, but that is not needed for this application. */ static void crc32c_zeros_op(uint32_t *even, size_t len) { uint32_t odd[32]; /* odd-power-of-two zeros operator */ /* put operator for one zero bit in odd */ odd[0] = POLY; /* CRC-32C polynomial */ uint32_t row = 1; for (unsigned n = 1; n < 32; n++) { odd[n] = row; row <<= 1; } /* put operator for two zero bits in even */ gf2_matrix_square(even, odd); /* put operator for four zero bits in odd */ gf2_matrix_square(odd, even); /* first square will put the operator for one zero byte (eight zero bits), in even -- next square puts operator for two zero bytes in odd, and so on, until len has been rotated down to zero */ do { gf2_matrix_square(even, odd); len >>= 1; if (len == 0) return; gf2_matrix_square(odd, even); len >>= 1; } while (len); /* answer ended up in odd -- copy to even */ for (unsigned n = 0; n < 32; n++) even[n] = odd[n]; } /* Take a length and build four lookup tables for applying the zeros operator for that length, byte-by-byte on the operand. */ static void crc32c_zeros(uint32_t zeros[][256], size_t len) { uint32_t op[32]; crc32c_zeros_op(op, len); for (unsigned n = 0; n < 256; n++) { zeros[0][n] = gf2_matrix_times(op, n); zeros[1][n] = gf2_matrix_times(op, n << 8); zeros[2][n] = gf2_matrix_times(op, n << 16); zeros[3][n] = gf2_matrix_times(op, n << 24); } } /* Apply the zeros operator table to crc. */ static inline uint32_t crc32c_shift(uint32_t zeros[][256], uint32_t crc) { return zeros[0][crc & 0xff] ^ zeros[1][(crc >> 8) & 0xff] ^ zeros[2][(crc >> 16) & 0xff] ^ zeros[3][crc >> 24]; } /* Block sizes for three-way parallel crc computation. LONG and SHORT must both be powers of two. The associated string constants must be set accordingly, for use in constructing the assembler instructions. */ #define LONG 8192 #define LONGx1 "8192" #define LONGx2 "16384" #define SHORT 256 #define SHORTx1 "256" #define SHORTx2 "512" /* Tables for hardware crc that shift a crc by LONG and SHORT zeros. */ static pthread_once_t crc32c_once_hw = PTHREAD_ONCE_INIT; static uint32_t crc32c_long[4][256]; static uint32_t crc32c_short[4][256]; /* Initialize tables for shifting crcs. */ static void crc32c_init_hw(void) { crc32c_zeros(crc32c_long, LONG); crc32c_zeros(crc32c_short, SHORT); } /* Compute CRC-32C using the Intel hardware instruction. */ static uint32_t crc32c_hw(uint32_t crc, void const *buf, size_t len) { /* populate shift tables the first time through */ pthread_once(&crc32c_once_hw, crc32c_init_hw); /* pre-process the crc */ crc = ~crc; uint64_t crc0 = crc; /* 64-bits for crc32q instruction */ /* compute the crc for up to seven leading bytes to bring the data pointer to an eight-byte boundary */ unsigned char const *next = buf; while (len && ((uintptr_t)next & 7) != 0) { __asm__("crc32b\t" "(%1), %0" : "=r"(crc0) : "r"(next), "0"(crc0)); next++; len--; } /* compute the crc on sets of LONG*3 bytes, executing three independent crc instructions, each on LONG bytes -- this is optimized for the Nehalem, Westmere, Sandy Bridge, and Ivy Bridge architectures, which have a throughput of one crc per cycle, but a latency of three cycles */ while (len >= LONG*3) { uint64_t crc1 = 0; uint64_t crc2 = 0; unsigned char const * const end = next + LONG; do { __asm__("crc32q\t" "(%3), %0\n\t" "crc32q\t" LONGx1 "(%3), %1\n\t" "crc32q\t" LONGx2 "(%3), %2" : "=r"(crc0), "=r"(crc1), "=r"(crc2) : "r"(next), "0"(crc0), "1"(crc1), "2"(crc2)); next += 8; } while (next < end); crc0 = crc32c_shift(crc32c_long, crc0) ^ crc1; crc0 = crc32c_shift(crc32c_long, crc0) ^ crc2; next += LONG*2; len -= LONG*3; } /* do the same thing, but now on SHORT*3 blocks for the remaining data less than a LONG*3 block */ while (len >= SHORT*3) { uint64_t crc1 = 0; uint64_t crc2 = 0; unsigned char const * const end = next + SHORT; do { __asm__("crc32q\t" "(%3), %0\n\t" "crc32q\t" SHORTx1 "(%3), %1\n\t" "crc32q\t" SHORTx2 "(%3), %2" : "=r"(crc0), "=r"(crc1), "=r"(crc2) : "r"(next), "0"(crc0), "1"(crc1), "2"(crc2)); next += 8; } while (next < end); crc0 = crc32c_shift(crc32c_short, crc0) ^ crc1; crc0 = crc32c_shift(crc32c_short, crc0) ^ crc2; next += SHORT*2; len -= SHORT*3; } /* compute the crc on the remaining eight-byte units less than a SHORT*3 block */ { unsigned char const * const end = next + (len - (len & 7)); while (next < end) { __asm__("crc32q\t" "(%1), %0" : "=r"(crc0) : "r"(next), "0"(crc0)); next += 8; } len &= 7; } /* compute the crc for up to seven trailing bytes */ while (len) { __asm__("crc32b\t" "(%1), %0" : "=r"(crc0) : "r"(next), "0"(crc0)); next++; len--; } /* return a post-processed crc */ return ~crc0; } /* Check for SSE 4.2. SSE 4.2 was first supported in Nehalem processors introduced in November, 2008. This does not check for the existence of the cpuid instruction itself, which was introduced on the 486SL in 1992, so this will fail on earlier x86 processors. cpuid works on all Pentium and later processors. */ #define SSE42(have) \ do { \ uint32_t eax, ecx; \ eax = 1; \ __asm__("cpuid" \ : "=c"(ecx) \ : "a"(eax) \ : "%ebx", "%edx"); \ (have) = (ecx >> 20) & 1; \ } while (0) /* Compute a CRC-32C. If the crc32 instruction is available, use the hardware version. Otherwise, use the software version. */ void crc32c_init(void) { int sse42; SSE42(sse42); if (sse42) { crc32c = crc32c_hw; } else { crc32c = crc32c_sw; } } #elif defined(__aarch64__) && (defined(__linux__) || defined(__APPLE__)) #if defined(__linux__) && defined(HAVE_SYS_AUX_H) #include #elif defined(__APPLE__) #include #endif #if defined(HWCAP_CRC32) static inline uint32_t crc32cx(uint32_t crc, const uint64_t data) { asm(".arch_extension crc\n" "crc32cx %w0, %w0, %x1" : "+r" (crc) : "r" (data)); return crc; } static inline uint32_t crc32cb(uint32_t crc, const uint8_t data) { asm(".arch_extension crc\n" "crc32cb %w0, %w0, %w1" : "+r" (crc) : "r" (data)); return crc; } static uint32_t crc32c_hw(uint32_t crc, void const *buf, size_t len) { crc = ~crc; unsigned char const *next = buf; while (((uintptr_t)next & 7) && len > 0) { crc = crc32cb(crc, *(uint8_t *)next); next++; len--; } while (len >= 64) { uint64_t *next8 = (uint64_t *)next; crc = crc32cx(crc, next8[0]); crc = crc32cx(crc, next8[1]); crc = crc32cx(crc, next8[2]); crc = crc32cx(crc, next8[3]); crc = crc32cx(crc, next8[4]); crc = crc32cx(crc, next8[5]); crc = crc32cx(crc, next8[6]); crc = crc32cx(crc, next8[7]); next += 64; len -= 64; } while (len >= 8) { crc = crc32cx(crc, *(uint64_t *)next); next += 8; len -= 8; } while (len > 0) { crc = crc32cb(crc, *(uint8_t *)next); next++; len--; } return ~crc; } void crc32c_init(void) { #if defined(__linux__) uint64_t auxv = getauxval(AT_HWCAP); crc32c = crc32c_sw; if (auxv & HWCAP_CRC32) crc32c = crc32c_hw; #elif defined(__APPLE__) int armv8_crc32; size_t size = sizeof(armv8_crc32); if (sysctlbyname("hw.optional.armv8_crc32", &armv8_crc32, &size, NULL, 0) == 0 && armv8_crc32 == 1) crc32c = crc32c_hw; #endif } #else /* no hw crc32 on arm64 system supported? old compiler/libc/kernel? */ void crc32c_init(void) { crc32c = crc32c_sw; } #endif #else /* !__x86_64__i && !__aarch64__ */ void crc32c_init(void) { crc32c = crc32c_sw; } #endif /* Construct table for software CRC-32C little-endian calculation. */ static pthread_once_t crc32c_once_little = PTHREAD_ONCE_INIT; static uint32_t crc32c_table_little[8][256]; static void crc32c_init_sw_little(void) { for (unsigned n = 0; n < 256; n++) { uint32_t crc = n; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc32c_table_little[0][n] = crc; } for (unsigned n = 0; n < 256; n++) { uint32_t crc = crc32c_table_little[0][n]; for (unsigned k = 1; k < 8; k++) { crc = crc32c_table_little[0][crc & 0xff] ^ (crc >> 8); crc32c_table_little[k][n] = crc; } } } /* Compute a CRC-32C in software assuming a little-endian architecture, constructing the required table if that hasn't already been done. */ uint32_t crc32c_sw_little(uint32_t crc, void const *buf, size_t len) { unsigned char const *next = buf; pthread_once(&crc32c_once_little, crc32c_init_sw_little); crc = ~crc; while (len && ((uintptr_t)next & 7) != 0) { crc = crc32c_table_little[0][(crc ^ *next++) & 0xff] ^ (crc >> 8); len--; } if (len >= 8) { uint64_t crcw = crc; do { crcw ^= *(uint64_t const *)next; crcw = crc32c_table_little[7][crcw & 0xff] ^ crc32c_table_little[6][(crcw >> 8) & 0xff] ^ crc32c_table_little[5][(crcw >> 16) & 0xff] ^ crc32c_table_little[4][(crcw >> 24) & 0xff] ^ crc32c_table_little[3][(crcw >> 32) & 0xff] ^ crc32c_table_little[2][(crcw >> 40) & 0xff] ^ crc32c_table_little[1][(crcw >> 48) & 0xff] ^ crc32c_table_little[0][crcw >> 56]; next += 8; len -= 8; } while (len >= 8); crc = crcw; } while (len) { crc = crc32c_table_little[0][(crc ^ *next++) & 0xff] ^ (crc >> 8); len--; } return ~crc; } /* Swap the bytes in a uint64_t. (Only for big-endian.) */ #if defined(__has_builtin) || (defined(__GNUC__) && \ (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) # define swap __builtin_bswap64 #else static inline uint64_t swap(uint64_t x) { x = ((x << 8) & 0xff00ff00ff00ff00) | ((x >> 8) & 0xff00ff00ff00ff); x = ((x << 16) & 0xffff0000ffff0000) | ((x >> 16) & 0xffff0000ffff); return (x << 32) | (x >> 32); } #endif /* Construct tables for software CRC-32C big-endian calculation. */ static pthread_once_t crc32c_once_big = PTHREAD_ONCE_INIT; static uint32_t crc32c_table_big_byte[256]; static uint64_t crc32c_table_big[8][256]; static void crc32c_init_sw_big(void) { for (unsigned n = 0; n < 256; n++) { uint32_t crc = n; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1; crc32c_table_big_byte[n] = crc; } for (unsigned n = 0; n < 256; n++) { uint32_t crc = crc32c_table_big_byte[n]; crc32c_table_big[0][n] = swap(crc); for (unsigned k = 1; k < 8; k++) { crc = crc32c_table_big_byte[crc & 0xff] ^ (crc >> 8); crc32c_table_big[k][n] = swap(crc); } } } /* Compute a CRC-32C in software assuming a big-endian architecture, constructing the required tables if that hasn't already been done. */ uint32_t crc32c_sw_big(uint32_t crc, void const *buf, size_t len) { unsigned char const *next = buf; pthread_once(&crc32c_once_big, crc32c_init_sw_big); crc = ~crc; while (len && ((uintptr_t)next & 7) != 0) { crc = crc32c_table_big_byte[(crc ^ *next++) & 0xff] ^ (crc >> 8); len--; } if (len >= 8) { uint64_t crcw = swap(crc); do { crcw ^= *(uint64_t const *)next; crcw = crc32c_table_big[0][crcw & 0xff] ^ crc32c_table_big[1][(crcw >> 8) & 0xff] ^ crc32c_table_big[2][(crcw >> 16) & 0xff] ^ crc32c_table_big[3][(crcw >> 24) & 0xff] ^ crc32c_table_big[4][(crcw >> 32) & 0xff] ^ crc32c_table_big[5][(crcw >> 40) & 0xff] ^ crc32c_table_big[6][(crcw >> 48) & 0xff] ^ crc32c_table_big[7][(crcw >> 56)]; next += 8; len -= 8; } while (len >= 8); crc = swap(crcw); } while (len) { crc = crc32c_table_big_byte[(crc ^ *next++) & 0xff] ^ (crc >> 8); len--; } return ~crc; } /* Table-driven software CRC-32C. This is about 15 times slower than using the hardware instructions. Determine the endianess of the processor and proceed accordingly. Ideally the endianess will be determined at compile time, in which case the unused functions and tables for the other endianess will be removed by the optimizer. If not, then the proper routines and tables will be used, even if the endianess is changed mid-stream. (Yes, there are processors that permit that -- go figure.) */ uint32_t crc32c_sw(uint32_t crc, void const *buf, size_t len) { static int const little = 1; if (*(char const *)&little) return crc32c_sw_little(crc, buf, len); else return crc32c_sw_big(crc, buf, len); } memcached-1.6.20/itoa_ljust.c0000664000175000017500000001217213704126374012764 00000000000000//=== itoa_ljust.cpp - Fast integer to ascii conversion --*- C++ -*-// // // Substantially simplified (and slightly faster) version // based on the following functions in Google's protocol buffers: // // FastInt32ToBufferLeft() // FastUInt32ToBufferLeft() // FastInt64ToBufferLeft() // FastUInt64ToBufferLeft() // // Differences: // 1) Greatly simplified // 2) Avoids GOTO statements - uses "switch" instead and relies on // compiler constant folding and propagation for high performance // 3) Avoids unary minus of signed types - undefined behavior if value // is INT_MIN in platforms using two's complement representation // 4) Uses memcpy to store 2 digits at a time - lets the compiler // generate a 2-byte load/store in platforms that support // unaligned access, this is faster (and less code) than explicitly // loading and storing each byte // // Copyright (c) 2016 Arturo Martin-de-Nicolas // arturomdn@gmail.com // https://github.com/amdn/itoa_ljust/ // // Released under the BSD 3-Clause License, see Google's original copyright // and license below. //===----------------------------------------------------------------------===// // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. //===----------------------------------------------------------------------===// #include "itoa_ljust.h" #include static const char lut[201] = "0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" "6061626364656667686970717273747576777879" "8081828384858687888990919293949596979899"; #define dd(u) ((const uint16_t)(lut[u])) static inline char* out2(const int d, char* p) { memcpy(p, &((uint16_t *)lut)[d], 2); return p + 2; } static inline char* out1(const char in, char* p) { memcpy(p, &in, 1); return p + 1; } static inline int digits( uint32_t u, unsigned k, int* d, char** p, int n ) { if (u < k*10) { *d = u / k; *p = out1('0'+*d, *p); --n; } return n; } static inline char* itoa(uint32_t u, char* p, int d, int n) { switch(n) { case 10: d = u / 100000000; p = out2( d, p ); case 9: u -= d * 100000000; case 8: d = u / 1000000; p = out2( d, p ); case 7: u -= d * 1000000; case 6: d = u / 10000; p = out2( d, p ); case 5: u -= d * 10000; case 4: d = u / 100; p = out2( d, p ); case 3: u -= d * 100; case 2: d = u / 1; p = out2( d, p ); case 1: ; } *p = '\0'; return p; } char* itoa_u32(uint32_t u, char* p) { int d = 0,n; if (u >=100000000) n = digits(u, 100000000, &d, &p, 10); else if (u < 100) n = digits(u, 1, &d, &p, 2); else if (u < 10000) n = digits(u, 100, &d, &p, 4); else if (u < 1000000) n = digits(u, 10000, &d, &p, 6); else n = digits(u, 1000000, &d, &p, 8); return itoa( u, p, d, n ); } char* itoa_32(int32_t i, char* p) { uint32_t u = i; if (i < 0) { *p++ = '-'; u = -u; } return itoa_u32(u, p); } char* itoa_u64(uint64_t u, char* p) { int d; uint32_t lower = (uint32_t)u; if (lower == u) return itoa_u32(lower, p); uint64_t upper = u / 1000000000; p = itoa_u64(upper, p); lower = u - (upper * 1000000000); d = lower / 100000000; p = out1('0'+d,p); return itoa( lower, p, d, 9 ); } char* itoa_64(int64_t i, char* p) { uint64_t u = i; if (i < 0) { *p++ = '-'; u = -u; } return itoa_u64(u, p); } memcached-1.6.20/timedrun.c0000664000175000017500000000600014402177543012427 00000000000000#include #include #include #include #include #include #include #include volatile sig_atomic_t caught_sig = 0; static void signal_handler(int which) { caught_sig = which; } static int wait_for_process(pid_t pid) { int rv = EX_SOFTWARE; int status = 0; int i = 0; struct sigaction sig_handler; memset(&sig_handler, 0, sizeof(struct sigaction)); sig_handler.sa_handler = signal_handler; sig_handler.sa_flags = 0; sigaction(SIGALRM, &sig_handler, NULL); sigaction(SIGHUP, &sig_handler, NULL); sigaction(SIGINT, &sig_handler, NULL); sigaction(SIGUSR1, &sig_handler, NULL); sigaction(SIGTERM, &sig_handler, NULL); sigaction(SIGPIPE, &sig_handler, NULL); /* Loop forever waiting for the process to quit */ for (i = 0; ;i++) { pid_t p = waitpid(pid, &status, 0); if (p == pid) { /* child exited. Let's get out of here */ rv = WIFEXITED(status) ? WEXITSTATUS(status) : (0x80 | WTERMSIG(status)); break; } else { int sig = 0; /* pass along SIGHUP gracefully */ if (caught_sig == SIGHUP) { i = 0; int sig = caught_sig; if (kill(pid, sig) < 0) { /* Kill failed. Must have lost the process. :/ */ perror("lost child when trying to kill"); } continue; } switch (i) { case 0: /* On the first iteration, pass the signal through */ sig = caught_sig > 0 ? caught_sig : SIGTERM; if (caught_sig == SIGALRM) { fprintf(stderr, "Timeout.. killing the process\n"); } break; case 1: sig = SIGTERM; break; default: sig = SIGKILL; break; } if (kill(pid, sig) < 0) { /* Kill failed. Must have lost the process. :/ */ perror("lost child when trying to kill"); } /* Wait up to 5 seconds for the pid */ alarm(5); } } return rv; } static int spawn_and_wait(char **argv) { int rv = EX_SOFTWARE; pid_t pid = fork(); switch (pid) { case -1: perror("fork"); rv = EX_OSERR; break; /* NOTREACHED */ case 0: execvp(argv[0], argv); perror("exec"); rv = EX_SOFTWARE; break; /* NOTREACHED */ default: rv = wait_for_process(pid); } return rv; } static void usage(void) { fprintf(stderr, "./timedrun args...\n"); exit(-1); } int main(int argc, char **argv) { int naptime = 0; if (argc < 3) usage(); naptime = atoi(argv[1]); assert(naptime > 0 && naptime < 1800); alarm(naptime); return spawn_and_wait(argv+2); } memcached-1.6.20/NEWS0000664000175000017500000000002714204760331011127 00000000000000https://memcached.org/ memcached-1.6.20/proto_bin.c0000664000175000017500000012567714427543277012631 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ /* * Functions for handling the binary protocol. * NOTE: The binary protocol is deprecated as of 1.6.0. */ #include "memcached.h" #include "proto_bin.h" #include "storage.h" #ifdef TLS #include "tls.h" #endif #include #include /** binprot handlers **/ static void process_bin_flush(conn *c, char *extbuf); static void process_bin_append_prepend(conn *c); static void process_bin_update(conn *c, char *extbuf); static void process_bin_get_or_touch(conn *c, char *extbuf); static void process_bin_delete(conn *c); static void complete_incr_bin(conn *c, char *extbuf); static void process_bin_stat(conn *c); static void process_bin_sasl_auth(conn *c); static void dispatch_bin_command(conn *c, char *extbuf); static void complete_update_bin(conn *c); static void process_bin_complete_sasl_auth(conn *c); static void write_bin_miss_response(conn *c, char *key, size_t nkey); void complete_nread_binary(conn *c) { assert(c != NULL); assert(c->cmd >= 0); switch(c->substate) { case bin_read_set_value: complete_update_bin(c); break; case bin_reading_sasl_auth_data: process_bin_complete_sasl_auth(c); if (c->item) { do_item_remove(c->item); c->item = NULL; } break; default: fprintf(stderr, "Not handling substate %d\n", c->substate); assert(0); } } int try_read_command_binary(conn *c) { /* Do we have the complete packet header? */ if (c->rbytes < sizeof(c->binary_header)) { /* need more data! */ return 0; } else { memcpy(&c->binary_header, c->rcurr, sizeof(c->binary_header)); protocol_binary_request_header* req; req = &c->binary_header; if (settings.verbose > 1) { /* Dump the packet before we convert it to host order */ int ii; fprintf(stderr, "<%d Read binary protocol data:", c->sfd); for (ii = 0; ii < sizeof(req->bytes); ++ii) { if (ii % 4 == 0) { fprintf(stderr, "\n<%d ", c->sfd); } fprintf(stderr, " 0x%02x", req->bytes[ii]); } fprintf(stderr, "\n"); } c->binary_header = *req; c->binary_header.request.keylen = ntohs(req->request.keylen); c->binary_header.request.bodylen = ntohl(req->request.bodylen); c->binary_header.request.cas = ntohll(req->request.cas); if (c->binary_header.request.magic != PROTOCOL_BINARY_REQ) { if (settings.verbose) { fprintf(stderr, "Invalid magic: %x\n", c->binary_header.request.magic); } conn_set_state(c, conn_closing); return -1; } uint8_t extlen = c->binary_header.request.extlen; uint16_t keylen = c->binary_header.request.keylen; if (c->rbytes < keylen + extlen + sizeof(c->binary_header)) { // Still need more bytes. Let try_read_network() realign the // read-buffer and fetch more data as necessary. return 0; } if (!resp_start(c)) { conn_set_state(c, conn_closing); return -1; } c->cmd = c->binary_header.request.opcode; c->keylen = c->binary_header.request.keylen; c->opaque = c->binary_header.request.opaque; /* clear the returned cas value */ c->cas = 0; c->last_cmd_time = current_time; // sigh. binprot has no "largest possible extlen" define, and I don't // want to refactor a ton of code either. Header is only ever used out // of c->binary_header, but the extlen stuff is used for the latter // bytes. Just wastes 24 bytes on the stack this way. // +4 need to be here because extbuf is used for protocol_binary_request_incr // and its member message is alligned to 48 bytes intead of 44 char extbuf[sizeof(c->binary_header) + BIN_MAX_EXTLEN+4]; memcpy(extbuf + sizeof(c->binary_header), c->rcurr + sizeof(c->binary_header), extlen > BIN_MAX_EXTLEN ? BIN_MAX_EXTLEN : extlen); c->rbytes -= sizeof(c->binary_header) + extlen + keylen; c->rcurr += sizeof(c->binary_header) + extlen + keylen; dispatch_bin_command(c, extbuf); } return 1; } /** * get a pointer to the key in this request */ static char* binary_get_key(conn *c) { return c->rcurr - (c->binary_header.request.keylen); } static void add_bin_header(conn *c, uint16_t err, uint8_t hdr_len, uint16_t key_len, uint32_t body_len) { protocol_binary_response_header* header; mc_resp *resp = c->resp; assert(c); resp_reset(resp); header = (protocol_binary_response_header *)resp->wbuf; header->response.magic = (uint8_t)PROTOCOL_BINARY_RES; header->response.opcode = c->binary_header.request.opcode; header->response.keylen = (uint16_t)htons(key_len); header->response.extlen = (uint8_t)hdr_len; header->response.datatype = (uint8_t)PROTOCOL_BINARY_RAW_BYTES; header->response.status = (uint16_t)htons(err); header->response.bodylen = htonl(body_len); header->response.opaque = c->opaque; header->response.cas = htonll(c->cas); if (settings.verbose > 1) { int ii; fprintf(stderr, ">%d Writing bin response:", c->sfd); for (ii = 0; ii < sizeof(header->bytes); ++ii) { if (ii % 4 == 0) { fprintf(stderr, "\n>%d ", c->sfd); } fprintf(stderr, " 0x%02x", header->bytes[ii]); } fprintf(stderr, "\n"); } resp->wbytes = sizeof(header->response); resp_add_iov(resp, resp->wbuf, resp->wbytes); } /** * Writes a binary error response. If errstr is supplied, it is used as the * error text; otherwise a generic description of the error status code is * included. */ void write_bin_error(conn *c, protocol_binary_response_status err, const char *errstr, int swallow) { size_t len; if (!errstr) { switch (err) { case PROTOCOL_BINARY_RESPONSE_ENOMEM: errstr = "Out of memory"; break; case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND: errstr = "Unknown command"; break; case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT: errstr = "Not found"; break; case PROTOCOL_BINARY_RESPONSE_EINVAL: errstr = "Invalid arguments"; break; case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS: errstr = "Data exists for key."; break; case PROTOCOL_BINARY_RESPONSE_E2BIG: errstr = "Too large."; break; case PROTOCOL_BINARY_RESPONSE_DELTA_BADVAL: errstr = "Non-numeric server-side value for incr or decr"; break; case PROTOCOL_BINARY_RESPONSE_NOT_STORED: errstr = "Not stored."; break; case PROTOCOL_BINARY_RESPONSE_AUTH_ERROR: errstr = "Auth failure."; break; default: assert(false); errstr = "UNHANDLED ERROR"; fprintf(stderr, ">%d UNHANDLED ERROR: %d\n", c->sfd, err); } } if (settings.verbose > 1) { fprintf(stderr, ">%d Writing an error: %s\n", c->sfd, errstr); } len = strlen(errstr); add_bin_header(c, err, 0, 0, len); if (len > 0) { resp_add_iov(c->resp, errstr, len); } if (swallow > 0) { c->sbytes = swallow; conn_set_state(c, conn_swallow); } else { conn_set_state(c, conn_mwrite); } } /* Just write an error message and disconnect the client */ static void handle_binary_protocol_error(conn *c) { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_EINVAL, NULL, 0); if (settings.verbose) { fprintf(stderr, "Protocol error (opcode %02x), close connection %d\n", c->binary_header.request.opcode, c->sfd); } c->close_after_write = true; } /* Form and send a response to a command over the binary protocol */ static void write_bin_response(conn *c, void *d, int hlen, int keylen, int dlen) { if (!c->noreply || c->cmd == PROTOCOL_BINARY_CMD_GET || c->cmd == PROTOCOL_BINARY_CMD_GETK) { add_bin_header(c, 0, hlen, keylen, dlen); mc_resp *resp = c->resp; if (dlen > 0) { resp_add_iov(resp, d, dlen); } } conn_set_state(c, conn_new_cmd); } static void complete_incr_bin(conn *c, char *extbuf) { item *it; char *key; size_t nkey; /* Weird magic in add_delta forces me to pad here */ char tmpbuf[INCR_MAX_STORAGE_LEN]; uint64_t cas = 0; assert(c != NULL); protocol_binary_response_incr* rsp = (protocol_binary_response_incr*)c->resp->wbuf; protocol_binary_request_incr* req = (void *)extbuf; //assert(c->wsize >= sizeof(*rsp)); /* fix byteorder in the request */ req->message.body.delta = ntohll(req->message.body.delta); req->message.body.initial = ntohll(req->message.body.initial); req->message.body.expiration = ntohl(req->message.body.expiration); key = binary_get_key(c); nkey = c->binary_header.request.keylen; if (settings.verbose > 1) { int i; fprintf(stderr, "incr "); for (i = 0; i < nkey; i++) { fprintf(stderr, "%c", key[i]); } fprintf(stderr, " %lld, %llu, %d\n", (long long)req->message.body.delta, (long long)req->message.body.initial, req->message.body.expiration); } if (c->binary_header.request.cas != 0) { cas = c->binary_header.request.cas; } switch(add_delta(c->thread, key, nkey, c->cmd == PROTOCOL_BINARY_CMD_INCREMENT, req->message.body.delta, tmpbuf, &cas)) { case OK: rsp->message.body.value = htonll(strtoull(tmpbuf, NULL, 10)); if (cas) { c->cas = cas; } write_bin_response(c, &rsp->message.body, 0, 0, sizeof(rsp->message.body.value)); break; case NON_NUMERIC: write_bin_error(c, PROTOCOL_BINARY_RESPONSE_DELTA_BADVAL, NULL, 0); break; case EOM: out_of_memory(c, "SERVER_ERROR Out of memory incrementing value"); break; case DELTA_ITEM_NOT_FOUND: if (req->message.body.expiration != 0xffffffff) { /* Save some room for the response */ rsp->message.body.value = htonll(req->message.body.initial); snprintf(tmpbuf, INCR_MAX_STORAGE_LEN, "%llu", (unsigned long long)req->message.body.initial); int res = strlen(tmpbuf); it = item_alloc(key, nkey, 0, realtime(req->message.body.expiration), res + 2); if (it != NULL) { uint64_t cas = 0; memcpy(ITEM_data(it), tmpbuf, res); memcpy(ITEM_data(it) + res, "\r\n", 2); c->thread->cur_sfd = c->sfd; // for store_item logging. if (store_item(it, NREAD_ADD, c->thread, NULL, &cas, CAS_NO_STALE)) { c->cas = cas; write_bin_response(c, &rsp->message.body, 0, 0, sizeof(rsp->message.body.value)); } else { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_NOT_STORED, NULL, 0); } item_remove(it); /* release our reference */ } else { out_of_memory(c, "SERVER_ERROR Out of memory allocating new item"); } } else { pthread_mutex_lock(&c->thread->stats.mutex); if (c->cmd == PROTOCOL_BINARY_CMD_INCREMENT) { c->thread->stats.incr_misses++; } else { c->thread->stats.decr_misses++; } pthread_mutex_unlock(&c->thread->stats.mutex); write_bin_error(c, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT, NULL, 0); } break; case DELTA_ITEM_CAS_MISMATCH: write_bin_error(c, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS, NULL, 0); break; } } static void complete_update_bin(conn *c) { protocol_binary_response_status eno = PROTOCOL_BINARY_RESPONSE_EINVAL; enum store_item_type ret = NOT_STORED; assert(c != NULL); item *it = c->item; pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.slab_stats[ITEM_clsid(it)].set_cmds++; pthread_mutex_unlock(&c->thread->stats.mutex); /* We don't actually receive the trailing two characters in the bin * protocol, so we're going to just set them here */ if ((it->it_flags & ITEM_CHUNKED) == 0) { *(ITEM_data(it) + it->nbytes - 2) = '\r'; *(ITEM_data(it) + it->nbytes - 1) = '\n'; } else { assert(c->ritem); item_chunk *ch = (item_chunk *) c->ritem; if (ch->size == ch->used) ch = ch->next; assert(ch->size - ch->used >= 2); ch->data[ch->used] = '\r'; ch->data[ch->used + 1] = '\n'; ch->used += 2; } uint64_t cas = 0; c->thread->cur_sfd = c->sfd; // for store_item logging. ret = store_item(it, c->cmd, c->thread, NULL, &cas, CAS_NO_STALE); c->cas = cas; #ifdef ENABLE_DTRACE switch (c->cmd) { case NREAD_ADD: MEMCACHED_COMMAND_ADD(c->sfd, ITEM_key(it), it->nkey, (ret == STORED) ? it->nbytes : -1, cas); break; case NREAD_REPLACE: MEMCACHED_COMMAND_REPLACE(c->sfd, ITEM_key(it), it->nkey, (ret == STORED) ? it->nbytes : -1, cas); break; case NREAD_APPEND: MEMCACHED_COMMAND_APPEND(c->sfd, ITEM_key(it), it->nkey, (ret == STORED) ? it->nbytes : -1, cas); break; case NREAD_PREPEND: MEMCACHED_COMMAND_PREPEND(c->sfd, ITEM_key(it), it->nkey, (ret == STORED) ? it->nbytes : -1, cas); break; case NREAD_SET: MEMCACHED_COMMAND_SET(c->sfd, ITEM_key(it), it->nkey, (ret == STORED) ? it->nbytes : -1, cas); break; } #endif switch (ret) { case STORED: /* Stored */ write_bin_response(c, NULL, 0, 0, 0); break; case EXISTS: write_bin_error(c, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS, NULL, 0); break; case NOT_FOUND: write_bin_error(c, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT, NULL, 0); break; case NOT_STORED: case TOO_LARGE: case NO_MEMORY: if (c->cmd == NREAD_ADD) { eno = PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS; } else if(c->cmd == NREAD_REPLACE) { eno = PROTOCOL_BINARY_RESPONSE_KEY_ENOENT; } else { eno = PROTOCOL_BINARY_RESPONSE_NOT_STORED; } write_bin_error(c, eno, NULL, 0); } item_remove(c->item); /* release the c->item reference */ c->item = 0; } static void write_bin_miss_response(conn *c, char *key, size_t nkey) { if (nkey) { add_bin_header(c, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT, 0, nkey, nkey); char *ofs = c->resp->wbuf + sizeof(protocol_binary_response_header); memcpy(ofs, key, nkey); resp_add_iov(c->resp, ofs, nkey); conn_set_state(c, conn_new_cmd); } else { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT, NULL, 0); } } static void process_bin_get_or_touch(conn *c, char *extbuf) { item *it; protocol_binary_response_get* rsp = (protocol_binary_response_get*)c->resp->wbuf; char* key = binary_get_key(c); size_t nkey = c->binary_header.request.keylen; int should_touch = (c->cmd == PROTOCOL_BINARY_CMD_TOUCH || c->cmd == PROTOCOL_BINARY_CMD_GAT || c->cmd == PROTOCOL_BINARY_CMD_GATK); int should_return_key = (c->cmd == PROTOCOL_BINARY_CMD_GETK || c->cmd == PROTOCOL_BINARY_CMD_GATK); int should_return_value = (c->cmd != PROTOCOL_BINARY_CMD_TOUCH); bool failed = false; if (settings.verbose > 1) { fprintf(stderr, "<%d %s ", c->sfd, should_touch ? "TOUCH" : "GET"); if (fwrite(key, 1, nkey, stderr)) {} fputc('\n', stderr); } if (should_touch) { protocol_binary_request_touch *t = (void *)extbuf; time_t exptime = ntohl(t->message.body.expiration); it = item_touch(key, nkey, realtime(exptime), c->thread); } else { it = item_get(key, nkey, c->thread, DO_UPDATE); } if (it) { /* the length has two unnecessary bytes ("\r\n") */ uint16_t keylen = 0; uint32_t bodylen = sizeof(rsp->message.body) + (it->nbytes - 2); pthread_mutex_lock(&c->thread->stats.mutex); if (should_touch) { c->thread->stats.touch_cmds++; c->thread->stats.slab_stats[ITEM_clsid(it)].touch_hits++; } else { c->thread->stats.get_cmds++; c->thread->stats.lru_hits[it->slabs_clsid]++; } pthread_mutex_unlock(&c->thread->stats.mutex); if (should_touch) { MEMCACHED_COMMAND_TOUCH(c->sfd, ITEM_key(it), it->nkey, it->nbytes, ITEM_get_cas(it)); } else { MEMCACHED_COMMAND_GET(c->sfd, ITEM_key(it), it->nkey, it->nbytes, ITEM_get_cas(it)); } if (c->cmd == PROTOCOL_BINARY_CMD_TOUCH) { bodylen -= it->nbytes - 2; } else if (should_return_key) { bodylen += nkey; keylen = nkey; } add_bin_header(c, 0, sizeof(rsp->message.body), keylen, bodylen); rsp->message.header.response.cas = htonll(ITEM_get_cas(it)); // add the flags FLAGS_CONV(it, rsp->message.body.flags); rsp->message.body.flags = htonl(rsp->message.body.flags); resp_add_iov(c->resp, &rsp->message.body, sizeof(rsp->message.body)); if (should_return_key) { resp_add_iov(c->resp, ITEM_key(it), nkey); } if (should_return_value) { /* Add the data minus the CRLF */ #ifdef EXTSTORE if (it->it_flags & ITEM_HDR) { if (storage_get_item(c, it, c->resp) != 0) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.get_oom_extstore++; pthread_mutex_unlock(&c->thread->stats.mutex); failed = true; } } else if ((it->it_flags & ITEM_CHUNKED) == 0) { resp_add_iov(c->resp, ITEM_data(it), it->nbytes - 2); } else { // Allow transmit handler to find the item and expand iov's resp_add_chunked_iov(c->resp, it, it->nbytes - 2); } #else if ((it->it_flags & ITEM_CHUNKED) == 0) { resp_add_iov(c->resp, ITEM_data(it), it->nbytes - 2); } else { resp_add_chunked_iov(c->resp, it, it->nbytes - 2); } #endif } if (!failed) { conn_set_state(c, conn_new_cmd); /* Remember this command so we can garbage collect it later */ #ifdef EXTSTORE if ((it->it_flags & ITEM_HDR) != 0 && should_return_value) { // Only have extstore clean if header and returning value. c->resp->item = NULL; } else { c->resp->item = it; } #else c->resp->item = it; #endif } else { item_remove(it); } } else { failed = true; } if (failed) { pthread_mutex_lock(&c->thread->stats.mutex); if (should_touch) { c->thread->stats.touch_cmds++; c->thread->stats.touch_misses++; } else { c->thread->stats.get_cmds++; c->thread->stats.get_misses++; } pthread_mutex_unlock(&c->thread->stats.mutex); if (should_touch) { MEMCACHED_COMMAND_TOUCH(c->sfd, key, nkey, -1, 0); } else { MEMCACHED_COMMAND_GET(c->sfd, key, nkey, -1, 0); } if (c->noreply) { conn_set_state(c, conn_new_cmd); } else { if (should_return_key) { write_bin_miss_response(c, key, nkey); } else { write_bin_miss_response(c, NULL, 0); } } } if (settings.detail_enabled) { stats_prefix_record_get(key, nkey, NULL != it); } } static void process_bin_stat(conn *c) { char *subcommand = binary_get_key(c); size_t nkey = c->binary_header.request.keylen; if (settings.verbose > 1) { int ii; fprintf(stderr, "<%d STATS ", c->sfd); for (ii = 0; ii < nkey; ++ii) { fprintf(stderr, "%c", subcommand[ii]); } fprintf(stderr, "\n"); } if (nkey == 0) { /* request all statistics */ server_stats(&append_stats, c); (void)get_stats(NULL, 0, &append_stats, c); } else if (strncmp(subcommand, "reset", 5) == 0) { stats_reset(); } else if (strncmp(subcommand, "settings", 8) == 0) { process_stat_settings(&append_stats, c); } else if (strncmp(subcommand, "detail", 6) == 0) { char *subcmd_pos = subcommand + 6; if (strncmp(subcmd_pos, " dump", 5) == 0) { int len; char *dump_buf = stats_prefix_dump(&len); if (dump_buf == NULL || len <= 0) { out_of_memory(c, "SERVER_ERROR Out of memory generating stats"); if (dump_buf != NULL) free(dump_buf); return; } else { append_stats("detailed", strlen("detailed"), dump_buf, len, c); free(dump_buf); } } else if (strncmp(subcmd_pos, " on", 3) == 0) { settings.detail_enabled = 1; } else if (strncmp(subcmd_pos, " off", 4) == 0) { settings.detail_enabled = 0; } else { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT, NULL, 0); return; } } else { if (get_stats(subcommand, nkey, &append_stats, c)) { if (c->stats.buffer == NULL) { out_of_memory(c, "SERVER_ERROR Out of memory generating stats"); } else { write_and_free(c, c->stats.buffer, c->stats.offset); c->stats.buffer = NULL; } } else { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT, NULL, 0); } return; } /* Append termination package and start the transfer */ append_stats(NULL, 0, NULL, 0, c); if (c->stats.buffer == NULL) { out_of_memory(c, "SERVER_ERROR Out of memory preparing to send stats"); } else { write_and_free(c, c->stats.buffer, c->stats.offset); c->stats.buffer = NULL; } } static void init_sasl_conn(conn *c) { assert(c); /* should something else be returned? */ if (!settings.sasl) return; c->authenticated = false; if (!c->sasl_conn) { int result=sasl_server_new("memcached", NULL, my_sasl_hostname[0] ? my_sasl_hostname : NULL, NULL, NULL, NULL, 0, &c->sasl_conn); if (result != SASL_OK) { if (settings.verbose) { fprintf(stderr, "Failed to initialize SASL conn.\n"); } c->sasl_conn = NULL; } } } static void bin_list_sasl_mechs(conn *c) { // Guard against a disabled SASL. if (!settings.sasl) { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND, NULL, c->binary_header.request.bodylen - c->binary_header.request.keylen); return; } init_sasl_conn(c); const char *result_string = NULL; unsigned int string_length = 0; int result=sasl_listmech(c->sasl_conn, NULL, "", /* What to prepend the string with */ " ", /* What to separate mechanisms with */ "", /* What to append to the string */ &result_string, &string_length, NULL); if (result != SASL_OK) { /* Perhaps there's a better error for this... */ if (settings.verbose) { fprintf(stderr, "Failed to list SASL mechanisms.\n"); } write_bin_error(c, PROTOCOL_BINARY_RESPONSE_AUTH_ERROR, NULL, 0); return; } write_bin_response(c, (char*)result_string, 0, 0, string_length); } static void process_bin_sasl_auth(conn *c) { // Guard for handling disabled SASL on the server. if (!settings.sasl) { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND, NULL, c->binary_header.request.bodylen - c->binary_header.request.keylen); return; } assert(c->binary_header.request.extlen == 0); int nkey = c->binary_header.request.keylen; int vlen = c->binary_header.request.bodylen - nkey; if (nkey > MAX_SASL_MECH_LEN) { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_EINVAL, NULL, vlen); conn_set_state(c, conn_swallow); return; } char *key = binary_get_key(c); assert(key); item *it = item_alloc(key, nkey, 0, 0, vlen+2); /* Can't use a chunked item for SASL authentication. */ if (it == 0 || (it->it_flags & ITEM_CHUNKED)) { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_ENOMEM, NULL, vlen); conn_set_state(c, conn_swallow); if (it) { do_item_remove(it); } return; } c->item = it; c->ritem = ITEM_data(it); c->rlbytes = vlen; conn_set_state(c, conn_nread); c->substate = bin_reading_sasl_auth_data; } static void process_bin_complete_sasl_auth(conn *c) { assert(settings.sasl); const char *out = NULL; unsigned int outlen = 0; assert(c->item); init_sasl_conn(c); int nkey = c->binary_header.request.keylen; int vlen = c->binary_header.request.bodylen - nkey; if (nkey > ((item*) c->item)->nkey) { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_EINVAL, NULL, vlen); conn_set_state(c, conn_swallow); return; } char mech[nkey+1]; memcpy(mech, ITEM_key((item*)c->item), nkey); mech[nkey] = 0x00; if (settings.verbose) fprintf(stderr, "mech: ``%s'' with %d bytes of data\n", mech, vlen); const char *challenge = vlen == 0 ? NULL : ITEM_data((item*) c->item); if (vlen > ((item*) c->item)->nbytes) { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_EINVAL, NULL, vlen); conn_set_state(c, conn_swallow); return; } int result=-1; switch (c->cmd) { case PROTOCOL_BINARY_CMD_SASL_AUTH: result = sasl_server_start(c->sasl_conn, mech, challenge, vlen, &out, &outlen); c->sasl_started = (result == SASL_OK || result == SASL_CONTINUE); break; case PROTOCOL_BINARY_CMD_SASL_STEP: if (!c->sasl_started) { if (settings.verbose) { fprintf(stderr, "%d: SASL_STEP called but sasl_server_start " "not called for this connection!\n", c->sfd); } break; } result = sasl_server_step(c->sasl_conn, challenge, vlen, &out, &outlen); break; default: assert(false); /* CMD should be one of the above */ /* This code is pretty much impossible, but makes the compiler happier */ if (settings.verbose) { fprintf(stderr, "Unhandled command %d with challenge %s\n", c->cmd, challenge); } break; } if (settings.verbose) { fprintf(stderr, "sasl result code: %d\n", result); } switch(result) { case SASL_OK: c->authenticated = true; write_bin_response(c, "Authenticated", 0, 0, strlen("Authenticated")); pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.auth_cmds++; pthread_mutex_unlock(&c->thread->stats.mutex); break; case SASL_CONTINUE: add_bin_header(c, PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE, 0, 0, outlen); if (outlen > 0) { resp_add_iov(c->resp, out, outlen); } // Immediately flush our write. conn_set_state(c, conn_mwrite); break; default: if (settings.verbose) fprintf(stderr, "Unknown sasl response: %d\n", result); write_bin_error(c, PROTOCOL_BINARY_RESPONSE_AUTH_ERROR, NULL, 0); pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.auth_cmds++; c->thread->stats.auth_errors++; pthread_mutex_unlock(&c->thread->stats.mutex); } } static bool authenticated(conn *c) { assert(settings.sasl); bool rv = false; switch (c->cmd) { case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS: /* FALLTHROUGH */ case PROTOCOL_BINARY_CMD_SASL_AUTH: /* FALLTHROUGH */ case PROTOCOL_BINARY_CMD_SASL_STEP: /* FALLTHROUGH */ case PROTOCOL_BINARY_CMD_VERSION: /* FALLTHROUGH */ rv = true; break; default: rv = c->authenticated; } if (settings.verbose > 1) { fprintf(stderr, "authenticated() in cmd 0x%02x is %s\n", c->cmd, rv ? "true" : "false"); } return rv; } static void dispatch_bin_command(conn *c, char *extbuf) { int protocol_error = 0; uint8_t extlen = c->binary_header.request.extlen; uint16_t keylen = c->binary_header.request.keylen; uint32_t bodylen = c->binary_header.request.bodylen; c->thread->cur_sfd = c->sfd; // cuddle sfd for logging. if (keylen > bodylen || keylen + extlen > bodylen) { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND, NULL, 0); c->close_after_write = true; return; } if (settings.sasl && !authenticated(c)) { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_AUTH_ERROR, NULL, 0); c->close_after_write = true; return; } MEMCACHED_PROCESS_COMMAND_START(c->sfd, c->rcurr, c->rbytes); c->noreply = true; /* binprot supports 16bit keys, but internals are still 8bit */ if (keylen > KEY_MAX_LENGTH) { handle_binary_protocol_error(c); return; } switch (c->cmd) { case PROTOCOL_BINARY_CMD_SETQ: c->cmd = PROTOCOL_BINARY_CMD_SET; break; case PROTOCOL_BINARY_CMD_ADDQ: c->cmd = PROTOCOL_BINARY_CMD_ADD; break; case PROTOCOL_BINARY_CMD_REPLACEQ: c->cmd = PROTOCOL_BINARY_CMD_REPLACE; break; case PROTOCOL_BINARY_CMD_DELETEQ: c->cmd = PROTOCOL_BINARY_CMD_DELETE; break; case PROTOCOL_BINARY_CMD_INCREMENTQ: c->cmd = PROTOCOL_BINARY_CMD_INCREMENT; break; case PROTOCOL_BINARY_CMD_DECREMENTQ: c->cmd = PROTOCOL_BINARY_CMD_DECREMENT; break; case PROTOCOL_BINARY_CMD_QUITQ: c->cmd = PROTOCOL_BINARY_CMD_QUIT; break; case PROTOCOL_BINARY_CMD_FLUSHQ: c->cmd = PROTOCOL_BINARY_CMD_FLUSH; break; case PROTOCOL_BINARY_CMD_APPENDQ: c->cmd = PROTOCOL_BINARY_CMD_APPEND; break; case PROTOCOL_BINARY_CMD_PREPENDQ: c->cmd = PROTOCOL_BINARY_CMD_PREPEND; break; case PROTOCOL_BINARY_CMD_GETQ: c->cmd = PROTOCOL_BINARY_CMD_GET; break; case PROTOCOL_BINARY_CMD_GETKQ: c->cmd = PROTOCOL_BINARY_CMD_GETK; break; case PROTOCOL_BINARY_CMD_GATQ: c->cmd = PROTOCOL_BINARY_CMD_GAT; break; case PROTOCOL_BINARY_CMD_GATKQ: c->cmd = PROTOCOL_BINARY_CMD_GATK; break; default: c->noreply = false; } switch (c->cmd) { case PROTOCOL_BINARY_CMD_VERSION: if (extlen == 0 && keylen == 0 && bodylen == 0) { write_bin_response(c, VERSION, 0, 0, strlen(VERSION)); } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_FLUSH: if (keylen == 0 && bodylen == extlen && (extlen == 0 || extlen == 4)) { process_bin_flush(c, extbuf); } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_NOOP: if (extlen == 0 && keylen == 0 && bodylen == 0) { write_bin_response(c, NULL, 0, 0, 0); // NOOP forces pipeline flush. conn_set_state(c, conn_mwrite); } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_SET: /* FALLTHROUGH */ case PROTOCOL_BINARY_CMD_ADD: /* FALLTHROUGH */ case PROTOCOL_BINARY_CMD_REPLACE: if (extlen == 8 && keylen != 0 && bodylen >= (keylen + 8)) { process_bin_update(c, extbuf); } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_GETQ: /* FALLTHROUGH */ case PROTOCOL_BINARY_CMD_GET: /* FALLTHROUGH */ case PROTOCOL_BINARY_CMD_GETKQ: /* FALLTHROUGH */ case PROTOCOL_BINARY_CMD_GETK: if (extlen == 0 && bodylen == keylen && keylen > 0) { process_bin_get_or_touch(c, extbuf); } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_DELETE: if (keylen > 0 && extlen == 0 && bodylen == keylen) { process_bin_delete(c); } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_INCREMENT: case PROTOCOL_BINARY_CMD_DECREMENT: if (keylen > 0 && extlen == 20 && bodylen == (keylen + extlen)) { complete_incr_bin(c, extbuf); } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_APPEND: case PROTOCOL_BINARY_CMD_PREPEND: if (keylen > 0 && extlen == 0) { process_bin_append_prepend(c); } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_STAT: if (extlen == 0) { process_bin_stat(c); } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_QUIT: if (keylen == 0 && extlen == 0 && bodylen == 0) { write_bin_response(c, NULL, 0, 0, 0); conn_set_state(c, conn_mwrite); c->close_after_write = true; c->close_reason = NORMAL_CLOSE; } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS: if (extlen == 0 && keylen == 0 && bodylen == 0) { bin_list_sasl_mechs(c); } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_SASL_AUTH: case PROTOCOL_BINARY_CMD_SASL_STEP: if (extlen == 0 && keylen != 0) { process_bin_sasl_auth(c); } else { protocol_error = 1; } break; case PROTOCOL_BINARY_CMD_TOUCH: case PROTOCOL_BINARY_CMD_GAT: case PROTOCOL_BINARY_CMD_GATQ: case PROTOCOL_BINARY_CMD_GATK: case PROTOCOL_BINARY_CMD_GATKQ: if (extlen == 4 && keylen != 0) { process_bin_get_or_touch(c, extbuf); } else { protocol_error = 1; } break; default: write_bin_error(c, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND, NULL, bodylen); } if (protocol_error) handle_binary_protocol_error(c); } static void process_bin_update(conn *c, char *extbuf) { char *key; int nkey; int vlen; item *it; protocol_binary_request_set* req = (void *)extbuf; assert(c != NULL); key = binary_get_key(c); nkey = c->binary_header.request.keylen; /* fix byteorder in the request */ req->message.body.flags = ntohl(req->message.body.flags); req->message.body.expiration = ntohl(req->message.body.expiration); vlen = c->binary_header.request.bodylen - (nkey + c->binary_header.request.extlen); if (settings.verbose > 1) { int ii; if (c->cmd == PROTOCOL_BINARY_CMD_ADD) { fprintf(stderr, "<%d ADD ", c->sfd); } else if (c->cmd == PROTOCOL_BINARY_CMD_SET) { fprintf(stderr, "<%d SET ", c->sfd); } else { fprintf(stderr, "<%d REPLACE ", c->sfd); } for (ii = 0; ii < nkey; ++ii) { fprintf(stderr, "%c", key[ii]); } fprintf(stderr, " Value len is %d", vlen); fprintf(stderr, "\n"); } if (settings.detail_enabled) { stats_prefix_record_set(key, nkey); } it = item_alloc(key, nkey, req->message.body.flags, realtime(req->message.body.expiration), vlen+2); if (it == 0) { enum store_item_type status; if (! item_size_ok(nkey, req->message.body.flags, vlen + 2)) { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_E2BIG, NULL, vlen); status = TOO_LARGE; } else { out_of_memory(c, "SERVER_ERROR Out of memory allocating item"); /* This error generating method eats the swallow value. Add here. */ c->sbytes = vlen; status = NO_MEMORY; } /* FIXME: losing c->cmd since it's translated below. refactor? */ LOGGER_LOG(c->thread->l, LOG_MUTATIONS, LOGGER_ITEM_STORE, NULL, status, 0, key, nkey, req->message.body.expiration, ITEM_clsid(it), c->sfd); /* Avoid stale data persisting in cache because we failed alloc. * Unacceptable for SET. Anywhere else too? */ if (c->cmd == PROTOCOL_BINARY_CMD_SET) { it = item_get(key, nkey, c->thread, DONT_UPDATE); if (it) { item_unlink(it); STORAGE_delete(c->thread->storage, it); item_remove(it); } } /* swallow the data line */ conn_set_state(c, conn_swallow); return; } ITEM_set_cas(it, c->binary_header.request.cas); switch (c->cmd) { case PROTOCOL_BINARY_CMD_ADD: c->cmd = NREAD_ADD; break; case PROTOCOL_BINARY_CMD_SET: c->cmd = NREAD_SET; break; case PROTOCOL_BINARY_CMD_REPLACE: c->cmd = NREAD_REPLACE; break; default: assert(0); } if (ITEM_get_cas(it) != 0) { c->cmd = NREAD_CAS; } c->item = it; #ifdef NEED_ALIGN if (it->it_flags & ITEM_CHUNKED) { c->ritem = ITEM_schunk(it); } else { c->ritem = ITEM_data(it); } #else c->ritem = ITEM_data(it); #endif c->rlbytes = vlen; conn_set_state(c, conn_nread); c->substate = bin_read_set_value; } static void process_bin_append_prepend(conn *c) { char *key; int nkey; int vlen; item *it; assert(c != NULL); key = binary_get_key(c); nkey = c->binary_header.request.keylen; vlen = c->binary_header.request.bodylen - nkey; if (settings.verbose > 1) { fprintf(stderr, "Value len is %d\n", vlen); } if (settings.detail_enabled) { stats_prefix_record_set(key, nkey); } it = item_alloc(key, nkey, 0, 0, vlen+2); if (it == 0) { if (! item_size_ok(nkey, 0, vlen + 2)) { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_E2BIG, NULL, vlen); } else { out_of_memory(c, "SERVER_ERROR Out of memory allocating item"); /* OOM calls eat the swallow value. Add here. */ c->sbytes = vlen; } /* swallow the data line */ conn_set_state(c, conn_swallow); return; } ITEM_set_cas(it, c->binary_header.request.cas); switch (c->cmd) { case PROTOCOL_BINARY_CMD_APPEND: c->cmd = NREAD_APPEND; break; case PROTOCOL_BINARY_CMD_PREPEND: c->cmd = NREAD_PREPEND; break; default: assert(0); } c->item = it; #ifdef NEED_ALIGN if (it->it_flags & ITEM_CHUNKED) { c->ritem = ITEM_schunk(it); } else { c->ritem = ITEM_data(it); } #else c->ritem = ITEM_data(it); #endif c->rlbytes = vlen; conn_set_state(c, conn_nread); c->substate = bin_read_set_value; } static void process_bin_flush(conn *c, char *extbuf) { time_t exptime = 0; protocol_binary_request_flush* req = (void *)extbuf; rel_time_t new_oldest = 0; if (!settings.flush_enabled) { // flush_all is not allowed but we log it on stats write_bin_error(c, PROTOCOL_BINARY_RESPONSE_AUTH_ERROR, NULL, 0); return; } if (c->binary_header.request.extlen == sizeof(req->message.body)) { exptime = ntohl(req->message.body.expiration); } if (exptime > 0) { new_oldest = realtime(exptime); } else { new_oldest = current_time; } if (settings.use_cas) { settings.oldest_live = new_oldest - 1; if (settings.oldest_live <= current_time) settings.oldest_cas = get_cas_id(); } else { settings.oldest_live = new_oldest; } pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.flush_cmds++; pthread_mutex_unlock(&c->thread->stats.mutex); write_bin_response(c, NULL, 0, 0, 0); } static void process_bin_delete(conn *c) { item *it; uint32_t hv; assert(c != NULL); char* key = binary_get_key(c); size_t nkey = c->binary_header.request.keylen; if (settings.verbose > 1) { int ii; fprintf(stderr, "Deleting "); for (ii = 0; ii < nkey; ++ii) { fprintf(stderr, "%c", key[ii]); } fprintf(stderr, "\n"); } if (settings.detail_enabled) { stats_prefix_record_delete(key, nkey); } it = item_get_locked(key, nkey, c->thread, DONT_UPDATE, &hv); if (it) { uint64_t cas = c->binary_header.request.cas; if (cas == 0 || cas == ITEM_get_cas(it)) { MEMCACHED_COMMAND_DELETE(c->sfd, ITEM_key(it), it->nkey); pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.slab_stats[ITEM_clsid(it)].delete_hits++; pthread_mutex_unlock(&c->thread->stats.mutex); do_item_unlink(it, hv); STORAGE_delete(c->thread->storage, it); write_bin_response(c, NULL, 0, 0, 0); } else { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS, NULL, 0); } do_item_remove(it); /* release our reference */ } else { write_bin_error(c, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT, NULL, 0); pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.delete_misses++; pthread_mutex_unlock(&c->thread->stats.mutex); } item_unlock(hv); } memcached-1.6.20/memcached_dtrace.d0000664000175000017500000002472414204760331014037 00000000000000/* * Copyright (c) <2008>, Sun Microsystems, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the nor the * names of its contributors may be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY SUN MICROSYSTEMS, INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL SUN MICROSYSTEMS, INC. BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ provider memcached { /** * Fired when a connection object is allocated from the connection pool. * @param connid the connection id */ probe conn__allocate(int connid); /** * Fired when a connection object is released back to the connection pool. * @param connid the connection id */ probe conn__release(int connid); /** * Fired when a new connection object is created (there are no more * connection objects in the connection pool). * @param ptr pointer to the connection object */ probe conn__create(void *ptr); /** * Fired when a connection object is destroyed ("released back to * the memory subsystem"). * @param ptr pointer to the connection object */ probe conn__destroy(void *ptr); /** * Fired when a connection is dispatched from the "main thread" to a * worker thread. * @param connid the connection id * @param threadid the thread id */ probe conn__dispatch(int connid, int64_t threadid); /** * Allocate memory from the slab allocator. * @param size the requested size * @param slabclass the allocation will be fulfilled in this class * @param slabsize the size of each item in this class * @param ptr pointer to allocated memory */ probe slabs__allocate(int size, int slabclass, int slabsize, void* ptr); /** * Failed to allocate memory (out of memory). * @param size the requested size * @param slabclass the class that failed to fulfill the request */ probe slabs__allocate__failed(int size, int slabclass); /** * Fired when a slab class attempts to allocate more space. * @param slabclass class that needs more memory */ probe slabs__slabclass__allocate(int slabclass); /** * Failed to allocate memory (out of memory). * @param slabclass the class that failed grab more memory */ probe slabs__slabclass__allocate__failed(int slabclass); /** * Release memory. * @param size the size of the memory * @param slabclass the class the memory belongs to * @param ptr pointer to the memory to release */ probe slabs__free(int size, int slabclass, void* ptr); /** * Fired when the when we have searched the hash table for a named key. * These two elements provide an insight in how well the hash function * functions. Long traversals are a sign of a less optimal function, * wasting cpu capacity. * * @param key the key searched for * @param keylen length of the key * @param depth the depth in the list of hash table */ probe assoc__find(const char *key, int keylen, int depth); /** * Fired when a new item has been inserted. * @param key the key just inserted * @param keylen length of the key */ probe assoc__insert(const char *key, int keylen); /** * Fired when a new item has been removed. * @param key the key just deleted * @param keylen length of the key */ probe assoc__delete(const char *key, int keylen); /** * Fired when an item is linked into the cache. * @param key the items key * @param keylen length of the key * @param size the size of the data */ probe item__link(const char *key, int keylen, int size); /** * Fired when an item is deleted. * @param key the items key * @param keylen length of the key * @param size the size of the data */ probe item__unlink(const char *key, int keylen, int size); /** * Fired when the refcount for an item is reduced. * @param key the items key * @param keylen length of the key * @param size the size of the data */ probe item__remove(const char *key, int keylen, int size); /** * Fired when the "last refenced" time is updated. * @param key the items key * @param keylen length of the key * @param size the size of the data */ probe item__update(const char *key, int keylen, int size); /** * Fired when an item is replaced with another item. * @param oldkey the key of the item to replace * @param oldkeylen the length of the old key * @param oldsize the size of the old item * @param newkey the key of the new item * @param newkeylen the length of the new key * @param newsize the size of the new item */ probe item__replace(const char *oldkey, int oldkeylen, int oldsize, const char *newkey, int newkeylen, int newsize); /** * Fired when the processing of a command starts. * @param connid the connection id * @param request the incoming request * @param size the size of the request */ probe process__command__start(int connid, const void *request, int size); /** * Fired when the processing of a command is done. * @param connid the connection id * @param response the response to send back to the client * @param size the size of the response */ probe process__command__end(int connid, const void *response, int size); /** * Fired for a get-command * @param connid connection id * @param key requested key * @param keylen length of the key * @param size size of the key's data (or signed int -1 if not found) * @param casid the casid for the item */ probe command__get(int connid, const char *key, int keylen, int size, int64_t casid); /** * Fired for an add-command. * @param connid connection id * @param key requested key * @param keylen length of the key * @param size the new size of the key's data (or signed int -1 if * not found) * @param casid the casid for the item */ probe command__add(int connid, const char *key, int keylen, int size, int64_t casid); /** * Fired for a set-command. * @param connid connection id * @param key requested key * @param keylen length of the key * @param size the new size of the key's data (or signed int -1 if * not found) * @param casid the casid for the item */ probe command__set(int connid, const char *key, int keylen, int size, int64_t casid); /** * Fired for a replace-command. * @param connid connection id * @param key requested key * @param keylen length of the key * @param size the new size of the key's data (or signed int -1 if * not found) * @param casid the casid for the item */ probe command__replace(int connid, const char *key, int keylen, int size, int64_t casid); /** * Fired for a prepend-command. * @param connid connection id * @param key requested key * @param keylen length of the key * @param size the new size of the key's data (or signed int -1 if * not found) * @param casid the casid for the item */ probe command__prepend(int connid, const char *key, int keylen, int size, int64_t casid); /** * Fired for an append-command. * @param connid connection id * @param key requested key * @param keylen length of the key * @param size the new size of the key's data (or signed int -1 if * not found) * @param casid the casid for the item */ probe command__append(int connid, const char *key, int keylen, int size, int64_t casid); /** * Fired for an touch-command. * @param connid connection id * @param key requested key * @param keylen length of the key * @param size the new size of the key's data (or signed int -1 if * not found) * @param casid the casid for the item */ probe command__touch(int connid, const char *key, int keylen, int size, int64_t casid); /** * Fired for a cas-command. * @param connid connection id * @param key requested key * @param keylen length of the key * @param size size of the key's data (or signed int -1 if not found) * @param casid the cas id requested */ probe command__cas(int connid, const char *key, int keylen, int size, int64_t casid); /** * Fired for an incr command. * @param connid connection id * @param key the requested key * @param keylen length of the key * @param val the new value */ probe command__incr(int connid, const char *key, int keylen, int64_t val); /** * Fired for a decr command. * @param connid connection id * @param key the requested key * @param keylen length of the key * @param val the new value */ probe command__decr(int connid, const char *key, int keylen, int64_t val); /** * Fired for a delete command. * @param connid connection id * @param key the requested key * @param keylen length of the key */ probe command__delete(int connid, const char *key, int keylen); }; #pragma D attributes Unstable/Unstable/Common provider memcached provider #pragma D attributes Private/Private/Common provider memcached module #pragma D attributes Private/Private/Common provider memcached function #pragma D attributes Unstable/Unstable/Common provider memcached name #pragma D attributes Unstable/Unstable/Common provider memcached args memcached-1.6.20/storage.h0000664000175000017500000000216514402177543012261 00000000000000#ifndef STORAGE_H #define STORAGE_H void storage_delete(void *e, item *it); #ifdef EXTSTORE #define STORAGE_delete(e, it) \ do { \ storage_delete(e, it); \ } while (0) #else #define STORAGE_delete(...) #endif // API. void storage_stats(ADD_STAT add_stats, conn *c); void process_extstore_stats(ADD_STAT add_stats, conn *c); bool storage_validate_item(void *e, item *it); int storage_get_item(conn *c, item *it, mc_resp *resp); // callback for the IO queue subsystem. void storage_submit_cb(io_queue_t *q); // Thread functions. int start_storage_write_thread(void *arg); void storage_write_pause(void); void storage_write_resume(void); int start_storage_compact_thread(void *arg); void storage_compact_pause(void); void storage_compact_resume(void); // Init functions. struct extstore_conf_file *storage_conf_parse(char *arg, unsigned int page_size); void *storage_init_config(struct settings *s); int storage_read_config(void *conf, char **subopt); int storage_check_config(void *conf); void *storage_init(void *conf); // Ignore pointers and header bits from the CRC #define STORE_OFFSET offsetof(item, nbytes) #endif memcached-1.6.20/itoa_ljust.h0000664000175000017500000000146613704126374012775 00000000000000#ifndef ITOA_LJUST_H #define ITOA_LJUST_H //=== itoa_ljust.h - Fast integer to ascii conversion // // Fast and simple integer to ASCII conversion: // // - 32 and 64-bit integers // - signed and unsigned // - user supplied buffer must be large enough for all decimal digits // in value plus minus sign if negative // - left-justified // - NUL terminated // - return value is pointer to NUL terminator // // Copyright (c) 2016 Arturo Martin-de-Nicolas // arturomdn@gmail.com // https://github.com/amdn/itoa_ljust/ //===----------------------------------------------------------------------===// #include char* itoa_u32(uint32_t u, char* buffer); char* itoa_32( int32_t i, char* buffer); char* itoa_u64(uint64_t u, char* buffer); char* itoa_64( int64_t i, char* buffer); #endif // ITOA_LJUST_H memcached-1.6.20/sasl_defs.h0000664000175000017500000000126513704126374012560 00000000000000#ifndef SASL_DEFS_H #define SASL_DEFS_H 1 // Longest one I could find was ``9798-U-RSA-SHA1-ENC'' #define MAX_SASL_MECH_LEN 32 #if defined(HAVE_SASL_SASL_H) && defined(ENABLE_SASL) #include void init_sasl(void); extern char my_sasl_hostname[1025]; #else /* End of SASL support */ typedef void* sasl_conn_t; #define init_sasl() {} #define sasl_dispose(x) {} #define sasl_server_new(a, b, c, d, e, f, g, h) 1 #define sasl_listmech(a, b, c, d, e, f, g, h) 1 #define sasl_server_start(a, b, c, d, e, f) 1 #define sasl_server_step(a, b, c, d, e) 1 #define sasl_getprop(a, b, c) {} #define SASL_OK 0 #define SASL_CONTINUE -1 #endif /* sasl compat */ #endif /* SASL_DEFS_H */ memcached-1.6.20/extstore.h0000664000175000017500000001075314206012033012454 00000000000000#ifndef EXTSTORE_H #define EXTSTORE_H /* A safe-to-read dataset for determining compaction. * id is the array index. */ struct extstore_page_data { uint64_t version; uint64_t bytes_used; unsigned int bucket; unsigned int free_bucket; }; /* Pages can have objects deleted from them at any time. This creates holes * that can't be reused until the page is either evicted or all objects are * deleted. * bytes_fragmented is the total bytes for all of these holes. * It is the size of all used pages minus each page's bytes_used value. */ struct extstore_stats { uint64_t page_allocs; uint64_t page_count; /* total page count */ uint64_t page_evictions; uint64_t page_reclaims; uint64_t page_size; /* size in bytes per page (supplied by caller) */ uint64_t pages_free; /* currently unallocated/unused pages */ uint64_t pages_used; uint64_t objects_evicted; uint64_t objects_read; uint64_t objects_written; uint64_t objects_used; /* total number of objects stored */ uint64_t bytes_evicted; uint64_t bytes_written; uint64_t bytes_read; /* wbuf - read -> bytes read from storage */ uint64_t bytes_used; /* total number of bytes stored */ uint64_t bytes_fragmented; /* see above comment */ uint64_t io_queue; struct extstore_page_data *page_data; }; // TODO: Temporary configuration structure. A "real" library should have an // extstore_set(enum, void *ptr) which hides the implementation. // this is plenty for quick development. struct extstore_conf { unsigned int page_size; // ideally 64-256M in size unsigned int page_count; unsigned int page_buckets; // number of different writeable pages unsigned int free_page_buckets; // buckets of dedicated pages (see code) unsigned int wbuf_size; // must divide cleanly into page_size unsigned int wbuf_count; // this might get locked to "2 per active page" unsigned int io_threadcount; unsigned int io_depth; // with normal I/O, hits locks less. req'd for AIO }; struct extstore_conf_file { unsigned int page_count; char *file; int fd; // internal usage uint64_t offset; // internal usage unsigned int bucket; // free page bucket unsigned int free_bucket; // specialized free bucket struct extstore_conf_file *next; }; enum obj_io_mode { OBJ_IO_READ = 0, OBJ_IO_WRITE, }; typedef struct _obj_io obj_io; typedef void (*obj_io_cb)(void *e, obj_io *io, int ret); /* An object for both reads and writes to the storage engine. * Once an IO is submitted, ->next may be changed by the IO thread. It is not * safe to further modify the IO stack until the entire request is completed. */ struct _obj_io { void *data; /* user supplied data pointer */ struct _obj_io *next; char *buf; /* buffer of data to read or write to */ struct iovec *iov; /* alternatively, use this iovec */ unsigned int iovcnt; /* number of IOV's */ unsigned int page_version; /* page version for read mode */ unsigned int len; /* for both modes */ unsigned int offset; /* for read mode */ unsigned short page_id; /* for read mode */ enum obj_io_mode mode; /* callback pointers? */ obj_io_cb cb; }; enum extstore_res { EXTSTORE_INIT_BAD_WBUF_SIZE = 1, EXTSTORE_INIT_NEED_MORE_WBUF, EXTSTORE_INIT_NEED_MORE_BUCKETS, EXTSTORE_INIT_PAGE_WBUF_ALIGNMENT, EXTSTORE_INIT_TOO_MANY_PAGES, EXTSTORE_INIT_OOM, EXTSTORE_INIT_OPEN_FAIL, EXTSTORE_INIT_THREAD_FAIL }; const char *extstore_err(enum extstore_res res); void *extstore_init(struct extstore_conf_file *fh, struct extstore_conf *cf, enum extstore_res *res); int extstore_write_request(void *ptr, unsigned int bucket, unsigned int free_bucket, obj_io *io); void extstore_write(void *ptr, obj_io *io); int extstore_submit(void *ptr, obj_io *io); /* count are the number of objects being removed, bytes are the original * length of those objects. Bytes is optional but you can't track * fragmentation without it. */ int extstore_check(void *ptr, unsigned int page_id, uint64_t page_version); int extstore_delete(void *ptr, unsigned int page_id, uint64_t page_version, unsigned int count, unsigned int bytes); void extstore_get_stats(void *ptr, struct extstore_stats *st); /* add page data array to a stats structure. * caller must allocate its stats.page_data memory first. */ void extstore_get_page_data(void *ptr, struct extstore_stats *st); void extstore_run_maint(void *ptr); void extstore_close_page(void *ptr, unsigned int page_id, uint64_t page_version); #endif memcached-1.6.20/memcached.c0000664000175000017500000067351314427543277012541 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ /* * memcached - memory caching daemon * * https://www.memcached.org/ * * Copyright 2003 Danga Interactive, Inc. All rights reserved. * * Use and distribution licensed under the BSD license. See * the LICENSE file for full text. * * Authors: * Anatoly Vorobey * Brad Fitzpatrick */ #include "memcached.h" #include "storage.h" #include "authfile.h" #include "restart.h" #include #include #include #include #include #include #include #include #include /* some POSIX systems need the following definition * to get mlockall flags out of sys/mman.h. */ #ifndef _P1003_1B_VISIBLE #define _P1003_1B_VISIBLE #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef HAVE_GETOPT_LONG #include #endif #ifdef TLS #include "tls.h" #endif #include "proto_text.h" #include "proto_bin.h" #include "proto_proxy.h" #if defined(__FreeBSD__) #include #endif /* * forward declarations */ static void drive_machine(conn *c); static int new_socket(struct addrinfo *ai); static ssize_t tcp_read(conn *arg, void *buf, size_t count); static ssize_t tcp_sendmsg(conn *arg, struct msghdr *msg, int flags); static ssize_t tcp_write(conn *arg, void *buf, size_t count); enum try_read_result { READ_DATA_RECEIVED, READ_NO_DATA_RECEIVED, READ_ERROR, /** an error occurred (on the socket) (or client closed connection) */ READ_MEMORY_ERROR /** failed to allocate more memory */ }; static int try_read_command_negotiate(conn *c); static int try_read_command_udp(conn *c); static enum try_read_result try_read_network(conn *c); static enum try_read_result try_read_udp(conn *c); static int start_conn_timeout_thread(void); /* stats */ static void stats_init(void); static void conn_to_str(const conn *c, char *addr, char *svr_addr); /* defaults */ static void settings_init(void); /* event handling, network IO */ static void event_handler(const evutil_socket_t fd, const short which, void *arg); static void conn_close(conn *c); static void conn_init(void); static bool update_event(conn *c, const int new_flags); static void complete_nread(conn *c); static void conn_free(conn *c); /** exported globals **/ struct stats stats; struct stats_state stats_state; struct settings settings; time_t process_started; /* when the process was started */ conn **conns; struct slab_rebalance slab_rebal; volatile int slab_rebalance_signal; #ifdef EXTSTORE /* hoping this is temporary; I'd prefer to cut globals, but will complete this * battle another day. */ void *ext_storage = NULL; #endif /** file scope variables **/ static conn *listen_conn = NULL; static int max_fds; static struct event_base *main_base; enum transmit_result { TRANSMIT_COMPLETE, /** All done writing. */ TRANSMIT_INCOMPLETE, /** More data remaining to write. */ TRANSMIT_SOFT_ERROR, /** Can't write any more right now. */ TRANSMIT_HARD_ERROR /** Can't write (c->state is set to conn_closing) */ }; /* Default methods to read from/ write to a socket */ ssize_t tcp_read(conn *c, void *buf, size_t count) { assert (c != NULL); return read(c->sfd, buf, count); } ssize_t tcp_sendmsg(conn *c, struct msghdr *msg, int flags) { assert (c != NULL); return sendmsg(c->sfd, msg, flags); } ssize_t tcp_write(conn *c, void *buf, size_t count) { assert (c != NULL); return write(c->sfd, buf, count); } static enum transmit_result transmit(conn *c); /* This reduces the latency without adding lots of extra wiring to be able to * notify the listener thread of when to listen again. * Also, the clock timer could be broken out into its own thread and we * can block the listener via a condition. */ static volatile bool allow_new_conns = true; static int stop_main_loop = NOT_STOP; static struct event maxconnsevent; static void maxconns_handler(const evutil_socket_t fd, const short which, void *arg) { struct timeval t = {.tv_sec = 0, .tv_usec = 10000}; if (fd == -42 || allow_new_conns == false) { /* reschedule in 10ms if we need to keep polling */ evtimer_set(&maxconnsevent, maxconns_handler, 0); event_base_set(main_base, &maxconnsevent); evtimer_add(&maxconnsevent, &t); } else { evtimer_del(&maxconnsevent); accept_new_conns(true); } } /* * given time value that's either unix time or delta from current unix time, return * unix time. Use the fact that delta can't exceed one month (and real time value can't * be that low). */ rel_time_t realtime(const time_t exptime) { /* no. of seconds in 30 days - largest possible delta exptime */ if (exptime == 0) return 0; /* 0 means never expire */ if (exptime > REALTIME_MAXDELTA) { /* if item expiration is at/before the server started, give it an expiration time of 1 second after the server started. (because 0 means don't expire). without this, we'd underflow and wrap around to some large value way in the future, effectively making items expiring in the past really expiring never */ if (exptime <= process_started) return (rel_time_t)1; return (rel_time_t)(exptime - process_started); } else { return (rel_time_t)(exptime + current_time); } } static void stats_init(void) { memset(&stats, 0, sizeof(struct stats)); memset(&stats_state, 0, sizeof(struct stats_state)); stats_state.accepting_conns = true; /* assuming we start in this state. */ /* make the time we started always be 2 seconds before we really did, so time(0) - time.started is never zero. if so, things like 'settings.oldest_live' which act as booleans as well as values are now false in boolean context... */ process_started = time(0) - ITEM_UPDATE_INTERVAL - 2; stats_prefix_init(settings.prefix_delimiter); } void stats_reset(void) { STATS_LOCK(); memset(&stats, 0, sizeof(struct stats)); stats_prefix_clear(); STATS_UNLOCK(); threadlocal_stats_reset(); item_stats_reset(); } static void settings_init(void) { settings.use_cas = true; settings.access = 0700; settings.port = 11211; settings.udpport = 0; #ifdef TLS settings.ssl_enabled = false; settings.ssl_ctx = NULL; settings.ssl_chain_cert = NULL; settings.ssl_key = NULL; settings.ssl_verify_mode = SSL_VERIFY_NONE; settings.ssl_keyformat = SSL_FILETYPE_PEM; settings.ssl_ciphers = NULL; settings.ssl_ca_cert = NULL; settings.ssl_last_cert_refresh_time = current_time; settings.ssl_wbuf_size = 16 * 1024; // default is 16KB (SSL max frame size is 17KB) settings.ssl_session_cache = false; settings.ssl_kernel_tls = false; settings.ssl_min_version = TLS1_2_VERSION; #endif /* By default this string should be NULL for getaddrinfo() */ settings.inter = NULL; settings.maxbytes = 64 * 1024 * 1024; /* default is 64MB */ settings.maxconns = 1024; /* to limit connections-related memory to about 5MB */ settings.verbose = 0; settings.oldest_live = 0; settings.oldest_cas = 0; /* supplements accuracy of oldest_live */ settings.evict_to_free = 1; /* push old items out of cache when memory runs out */ settings.socketpath = NULL; /* by default, not using a unix socket */ settings.auth_file = NULL; /* by default, not using ASCII authentication tokens */ settings.factor = 1.25; settings.chunk_size = 48; /* space for a modest key and value */ settings.num_threads = 4; /* N workers */ settings.num_threads_per_udp = 0; settings.prefix_delimiter = ':'; settings.detail_enabled = 0; settings.reqs_per_event = 20; settings.backlog = 1024; settings.binding_protocol = negotiating_prot; settings.item_size_max = 1024 * 1024; /* The famous 1MB upper limit. */ settings.slab_page_size = 1024 * 1024; /* chunks are split from 1MB pages. */ settings.slab_chunk_size_max = settings.slab_page_size / 2; settings.sasl = false; settings.maxconns_fast = true; settings.lru_crawler = false; settings.lru_crawler_sleep = 100; settings.lru_crawler_tocrawl = 0; settings.lru_maintainer_thread = false; settings.lru_segmented = true; settings.hot_lru_pct = 20; settings.warm_lru_pct = 40; settings.hot_max_factor = 0.2; settings.warm_max_factor = 2.0; settings.temp_lru = false; settings.temporary_ttl = 61; settings.idle_timeout = 0; /* disabled */ settings.hashpower_init = 0; settings.slab_reassign = true; settings.slab_automove = 1; settings.slab_automove_ratio = 0.8; settings.slab_automove_window = 30; settings.shutdown_command = false; settings.tail_repair_time = TAIL_REPAIR_TIME_DEFAULT; settings.flush_enabled = true; settings.dump_enabled = true; settings.crawls_persleep = 1000; settings.logger_watcher_buf_size = LOGGER_WATCHER_BUF_SIZE; settings.logger_buf_size = LOGGER_BUF_SIZE; settings.drop_privileges = false; settings.watch_enabled = true; settings.read_buf_mem_limit = 0; #ifdef MEMCACHED_DEBUG settings.relaxed_privileges = false; #endif settings.num_napi_ids = 0; settings.memory_file = NULL; #ifdef SOCK_COOKIE_ID settings.sock_cookie_id = 0; #endif } extern pthread_mutex_t conn_lock; /* Connection timeout thread bits */ static pthread_t conn_timeout_tid; static int do_run_conn_timeout_thread; static pthread_cond_t conn_timeout_cond = PTHREAD_COND_INITIALIZER; static pthread_mutex_t conn_timeout_lock = PTHREAD_MUTEX_INITIALIZER; #define CONNS_PER_SLICE 100 static void *conn_timeout_thread(void *arg) { int i; conn *c; rel_time_t oldest_last_cmd; int sleep_time; int sleep_slice = max_fds / CONNS_PER_SLICE; if (sleep_slice == 0) sleep_slice = CONNS_PER_SLICE; useconds_t timeslice = 1000000 / sleep_slice; mutex_lock(&conn_timeout_lock); while(do_run_conn_timeout_thread) { if (settings.verbose > 2) fprintf(stderr, "idle timeout thread at top of connection list\n"); oldest_last_cmd = current_time; for (i = 0; i < max_fds; i++) { if ((i % CONNS_PER_SLICE) == 0) { if (settings.verbose > 2) fprintf(stderr, "idle timeout thread sleeping for %ulus\n", (unsigned int)timeslice); usleep(timeslice); } if (!conns[i]) continue; c = conns[i]; if (!IS_TCP(c->transport)) continue; if (c->state != conn_new_cmd && c->state != conn_read) continue; if ((current_time - c->last_cmd_time) > settings.idle_timeout) { timeout_conn(c); } else { if (c->last_cmd_time < oldest_last_cmd) oldest_last_cmd = c->last_cmd_time; } } /* This is the soonest we could have another connection time out */ sleep_time = settings.idle_timeout - (current_time - oldest_last_cmd) + 1; if (sleep_time <= 0) sleep_time = 1; if (settings.verbose > 2) fprintf(stderr, "idle timeout thread finished pass, sleeping for %ds\n", sleep_time); struct timeval now; struct timespec to_sleep; gettimeofday(&now, NULL); to_sleep.tv_sec = now.tv_sec + sleep_time; to_sleep.tv_nsec = 0; pthread_cond_timedwait(&conn_timeout_cond, &conn_timeout_lock, &to_sleep); } mutex_unlock(&conn_timeout_lock); return NULL; } static int start_conn_timeout_thread(void) { int ret; if (settings.idle_timeout == 0) return -1; do_run_conn_timeout_thread = 1; if ((ret = pthread_create(&conn_timeout_tid, NULL, conn_timeout_thread, NULL)) != 0) { fprintf(stderr, "Can't create idle connection timeout thread: %s\n", strerror(ret)); return -1; } thread_setname(conn_timeout_tid, "mc-idletimeout"); return 0; } int stop_conn_timeout_thread(void) { if (!do_run_conn_timeout_thread) return -1; mutex_lock(&conn_timeout_lock); do_run_conn_timeout_thread = 0; pthread_cond_signal(&conn_timeout_cond); mutex_unlock(&conn_timeout_lock); pthread_join(conn_timeout_tid, NULL); return 0; } /* * read buffer cache helper functions */ static void rbuf_release(conn *c) { if (c->rbuf != NULL && c->rbytes == 0 && !IS_UDP(c->transport)) { if (c->rbuf_malloced) { free(c->rbuf); c->rbuf_malloced = false; } else { do_cache_free(c->thread->rbuf_cache, c->rbuf); } c->rsize = 0; c->rbuf = NULL; c->rcurr = NULL; } } static bool rbuf_alloc(conn *c) { if (c->rbuf == NULL) { c->rbuf = do_cache_alloc(c->thread->rbuf_cache); if (!c->rbuf) { THR_STATS_LOCK(c->thread); c->thread->stats.read_buf_oom++; THR_STATS_UNLOCK(c->thread); return false; } c->rsize = READ_BUFFER_SIZE; c->rcurr = c->rbuf; } return true; } // Just for handling huge ASCII multigets. // The previous system was essentially the same; realloc'ing until big enough, // then realloc'ing back down after the request finished. bool rbuf_switch_to_malloc(conn *c) { // Might as well start with x2 and work from there. size_t size = c->rsize * 2; char *tmp = malloc(size); if (!tmp) return false; memcpy(tmp, c->rcurr, c->rbytes); do_cache_free(c->thread->rbuf_cache, c->rbuf); c->rcurr = c->rbuf = tmp; c->rsize = size; c->rbuf_malloced = true; return true; } /* * Initializes the connections array. We don't actually allocate connection * structures until they're needed, so as to avoid wasting memory when the * maximum connection count is much higher than the actual number of * connections. * * This does end up wasting a few pointers' worth of memory for FDs that are * used for things other than connections, but that's worth it in exchange for * being able to directly index the conns array by FD. */ static void conn_init(void) { /* We're unlikely to see an FD much higher than maxconns. */ int next_fd = dup(1); if (next_fd < 0) { perror("Failed to duplicate file descriptor\n"); exit(1); } int headroom = 10; /* account for extra unexpected open FDs */ struct rlimit rl; max_fds = settings.maxconns + headroom + next_fd; /* But if possible, get the actual highest FD we can possibly ever see. */ if (getrlimit(RLIMIT_NOFILE, &rl) == 0) { max_fds = rl.rlim_max; } else { fprintf(stderr, "Failed to query maximum file descriptor; " "falling back to maxconns\n"); } close(next_fd); if ((conns = calloc(max_fds, sizeof(conn *))) == NULL) { fprintf(stderr, "Failed to allocate connection structures\n"); /* This is unrecoverable so bail out early. */ exit(1); } } static const char *prot_text(enum protocol prot) { char *rv = "unknown"; switch(prot) { case ascii_prot: rv = "ascii"; break; case binary_prot: rv = "binary"; break; case negotiating_prot: rv = "auto-negotiate"; break; #ifdef PROXY case proxy_prot: rv = "proxy"; break; #endif } return rv; } void conn_close_idle(conn *c) { if (settings.idle_timeout > 0 && (current_time - c->last_cmd_time) > settings.idle_timeout) { if (c->state != conn_new_cmd && c->state != conn_read) { if (settings.verbose > 1) fprintf(stderr, "fd %d wants to timeout, but isn't in read state", c->sfd); return; } if (settings.verbose > 1) fprintf(stderr, "Closing idle fd %d\n", c->sfd); pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.idle_kicks++; pthread_mutex_unlock(&c->thread->stats.mutex); c->close_reason = IDLE_TIMEOUT_CLOSE; conn_set_state(c, conn_closing); drive_machine(c); } } /* bring conn back from a sidethread. could have had its event base moved. */ void conn_worker_readd(conn *c) { if (c->state == conn_io_queue) { c->io_queues_submitted--; // If we're still waiting for other queues to return, don't re-add the // connection yet. if (c->io_queues_submitted != 0) { return; } } c->ev_flags = EV_READ | EV_PERSIST; event_set(&c->event, c->sfd, c->ev_flags, event_handler, (void *)c); event_base_set(c->thread->base, &c->event); // TODO: call conn_cleanup/fail/etc if (event_add(&c->event, 0) == -1) { perror("event_add"); } // side thread wanted us to close immediately. if (c->state == conn_closing) { drive_machine(c); return; } else if (c->state == conn_io_queue) { // machine will know how to return based on secondary state. drive_machine(c); } else { conn_set_state(c, conn_new_cmd); } } void thread_io_queue_add(LIBEVENT_THREAD *t, int type, void *ctx, io_queue_stack_cb cb) { io_queue_cb_t *q = t->io_queues; while (q->type != IO_QUEUE_NONE) { q++; } q->type = type; q->ctx = ctx; q->submit_cb = cb; return; } void conn_io_queue_setup(conn *c) { io_queue_cb_t *qcb = c->thread->io_queues; io_queue_t *q = c->io_queues; while (qcb->type != IO_QUEUE_NONE) { q->type = qcb->type; q->ctx = qcb->ctx; q->stack_ctx = NULL; q->count = 0; qcb++; q++; } } // To be called from conn_release_items to ensure the stack ptrs are reset. static void conn_io_queue_reset(conn *c) { for (io_queue_t *q = c->io_queues; q->type != IO_QUEUE_NONE; q++) { assert(q->count == 0); q->stack_ctx = NULL; } } io_queue_cb_t *thread_io_queue_get(LIBEVENT_THREAD *t, int type) { io_queue_cb_t *q = t->io_queues; while (q->type != IO_QUEUE_NONE) { if (q->type == type) { return q; } q++; } return NULL; } io_queue_t *conn_io_queue_get(conn *c, int type) { io_queue_t *q = c->io_queues; while (q->type != IO_QUEUE_NONE) { if (q->type == type) { return q; } q++; } return NULL; } // called to return a single IO object to the original worker thread. void conn_io_queue_return(io_pending_t *io) { io->return_cb(io); } conn *conn_new(const int sfd, enum conn_states init_state, const int event_flags, const int read_buffer_size, enum network_transport transport, struct event_base *base, void *ssl, uint64_t conntag, enum protocol bproto) { conn *c; assert(sfd >= 0 && sfd < max_fds); c = conns[sfd]; if (NULL == c) { if (!(c = (conn *)calloc(1, sizeof(conn)))) { STATS_LOCK(); stats.malloc_fails++; STATS_UNLOCK(); fprintf(stderr, "Failed to allocate connection object\n"); return NULL; } MEMCACHED_CONN_CREATE(c); c->read = NULL; c->sendmsg = NULL; c->write = NULL; c->rbuf = NULL; c->rsize = read_buffer_size; // UDP connections use a persistent static buffer. if (c->rsize) { c->rbuf = (char *)malloc((size_t)c->rsize); } if (c->rsize && c->rbuf == NULL) { conn_free(c); STATS_LOCK(); stats.malloc_fails++; STATS_UNLOCK(); fprintf(stderr, "Failed to allocate buffers for connection\n"); return NULL; } STATS_LOCK(); stats_state.conn_structs++; STATS_UNLOCK(); c->sfd = sfd; conns[sfd] = c; } c->transport = transport; c->protocol = bproto; c->tag = conntag; /* unix socket mode doesn't need this, so zeroed out. but why * is this done for every command? presumably for UDP * mode. */ if (!settings.socketpath) { c->request_addr_size = sizeof(c->request_addr); } else { c->request_addr_size = 0; } if (transport == tcp_transport && init_state == conn_new_cmd) { if (getpeername(sfd, (struct sockaddr *) &c->request_addr, &c->request_addr_size)) { perror("getpeername"); memset(&c->request_addr, 0, sizeof(c->request_addr)); } } if (init_state == conn_new_cmd) { LOGGER_LOG(NULL, LOG_CONNEVENTS, LOGGER_CONNECTION_NEW, NULL, &c->request_addr, c->request_addr_size, c->transport, 0, sfd); } if (settings.verbose > 1) { if (init_state == conn_listening) { fprintf(stderr, "<%d server listening (%s)\n", sfd, prot_text(c->protocol)); } else if (IS_UDP(transport)) { fprintf(stderr, "<%d server listening (udp)\n", sfd); } else if (c->protocol == negotiating_prot) { fprintf(stderr, "<%d new auto-negotiating client connection\n", sfd); } else if (c->protocol == ascii_prot) { fprintf(stderr, "<%d new ascii client connection.\n", sfd); } else if (c->protocol == binary_prot) { fprintf(stderr, "<%d new binary client connection.\n", sfd); #ifdef PROXY } else if (c->protocol == proxy_prot) { fprintf(stderr, "<%d new proxy client connection.\n", sfd); #endif } else { fprintf(stderr, "<%d new unknown (%d) client connection\n", sfd, c->protocol); assert(false); } } #ifdef TLS c->ssl = NULL; c->ssl_wbuf = NULL; c->ssl_enabled = false; #endif c->state = init_state; c->rlbytes = 0; c->cmd = -1; c->rbytes = 0; c->rcurr = c->rbuf; c->ritem = 0; c->rbuf_malloced = false; c->item_malloced = false; c->sasl_started = false; c->set_stale = false; c->mset_res = false; c->close_after_write = false; c->last_cmd_time = current_time; /* initialize for idle kicker */ // wipe all queues. memset(c->io_queues, 0, sizeof(c->io_queues)); c->io_queues_submitted = 0; c->item = 0; c->noreply = false; #ifdef TLS if (ssl) { c->ssl = (SSL*)ssl; c->read = ssl_read; c->sendmsg = ssl_sendmsg; c->write = ssl_write; c->ssl_enabled = true; SSL_set_info_callback(c->ssl, ssl_callback); } else #else // This must be NULL if TLS is not enabled. assert(ssl == NULL); #endif { c->read = tcp_read; c->sendmsg = tcp_sendmsg; c->write = tcp_write; } if (IS_UDP(transport)) { c->try_read_command = try_read_command_udp; } else { switch (c->protocol) { case ascii_prot: if (settings.auth_file == NULL) { c->authenticated = true; c->try_read_command = try_read_command_ascii; } else { c->authenticated = false; c->try_read_command = try_read_command_asciiauth; } break; case binary_prot: // binprot handles its own authentication via SASL parsing. c->authenticated = false; c->try_read_command = try_read_command_binary; break; case negotiating_prot: c->try_read_command = try_read_command_negotiate; break; #ifdef PROXY case proxy_prot: c->try_read_command = try_read_command_proxy; break; #endif } } event_set(&c->event, sfd, event_flags, event_handler, (void *)c); event_base_set(base, &c->event); c->ev_flags = event_flags; if (event_add(&c->event, 0) == -1) { perror("event_add"); return NULL; } STATS_LOCK(); stats_state.curr_conns++; stats.total_conns++; STATS_UNLOCK(); MEMCACHED_CONN_ALLOCATE(c->sfd); return c; } void conn_release_items(conn *c) { assert(c != NULL); if (c->item) { if (c->item_malloced) { free(c->item); c->item_malloced = false; } else { item_remove(c->item); } c->item = 0; } // Cull any unsent responses. if (c->resp_head) { mc_resp *resp = c->resp_head; // r_f() handles the chain maintenance. while (resp) { // temporary by default. hide behind a debug flag in the future: // double free detection. Transmit loops can drop out early, but // here we could infinite loop. if (resp->free) { fprintf(stderr, "ERROR: double free detected during conn_release_items(): [%d] [%s]\n", c->sfd, c->protocol == binary_prot ? "binary" : "ascii"); // Since this is a critical failure, just leak the memory. // If these errors are seen, an abort() can be used instead. c->resp_head = NULL; c->resp = NULL; break; } resp = resp_finish(c, resp); } conn_io_queue_reset(c); } } static void conn_cleanup(conn *c) { assert(c != NULL); conn_release_items(c); #ifdef PROXY if (c->proxy_coro_ref) { proxy_cleanup_conn(c); } #endif if (c->sasl_conn) { assert(settings.sasl); sasl_dispose(&c->sasl_conn); c->sasl_conn = NULL; } if (IS_UDP(c->transport)) { conn_set_state(c, conn_read); } } /* * Frees a connection. */ void conn_free(conn *c) { if (c) { assert(c != NULL); assert(c->sfd >= 0 && c->sfd < max_fds); MEMCACHED_CONN_DESTROY(c); conns[c->sfd] = NULL; if (c->rbuf) free(c->rbuf); #ifdef TLS if (c->ssl_wbuf) c->ssl_wbuf = NULL; #endif free(c); } } static void conn_close(conn *c) { assert(c != NULL); if (c->thread) { LOGGER_LOG(c->thread->l, LOG_CONNEVENTS, LOGGER_CONNECTION_CLOSE, NULL, &c->request_addr, c->request_addr_size, c->transport, c->close_reason, c->sfd); } /* delete the event, the socket and the conn */ event_del(&c->event); if (settings.verbose > 1) fprintf(stderr, "<%d connection closed.\n", c->sfd); conn_cleanup(c); // force release of read buffer. if (c->thread) { c->rbytes = 0; rbuf_release(c); } MEMCACHED_CONN_RELEASE(c->sfd); conn_set_state(c, conn_closed); #ifdef TLS if (c->ssl) { SSL_shutdown(c->ssl); SSL_free(c->ssl); } #endif close(c->sfd); c->close_reason = 0; pthread_mutex_lock(&conn_lock); allow_new_conns = true; pthread_mutex_unlock(&conn_lock); STATS_LOCK(); stats_state.curr_conns--; STATS_UNLOCK(); return; } // Since some connections might be off on side threads and some are managed as // listeners we need to walk through them all from a central point. // Must be called with all worker threads hung or in the process of closing. void conn_close_all(void) { int i; for (i = 0; i < max_fds; i++) { if (conns[i] && conns[i]->state != conn_closed) { conn_close(conns[i]); } } } /** * Convert a state name to a human readable form. */ static const char *state_text(enum conn_states state) { const char* const statenames[] = { "conn_listening", "conn_new_cmd", "conn_waiting", "conn_read", "conn_parse_cmd", "conn_write", "conn_nread", "conn_swallow", "conn_closing", "conn_mwrite", "conn_closed", "conn_watch", "conn_io_queue" }; return statenames[state]; } /* * Sets a connection's current state in the state machine. Any special * processing that needs to happen on certain state transitions can * happen here. */ void conn_set_state(conn *c, enum conn_states state) { assert(c != NULL); assert(state >= conn_listening && state < conn_max_state); if (state != c->state) { if (settings.verbose > 2) { fprintf(stderr, "%d: going from %s to %s\n", c->sfd, state_text(c->state), state_text(state)); } if (state == conn_write || state == conn_mwrite) { MEMCACHED_PROCESS_COMMAND_END(c->sfd, c->resp->wbuf, c->resp->wbytes); } c->state = state; } } /* * response object helper functions */ void resp_reset(mc_resp *resp) { if (resp->item) { item_remove(resp->item); resp->item = NULL; } if (resp->write_and_free) { free(resp->write_and_free); resp->write_and_free = NULL; } resp->wbytes = 0; resp->tosend = 0; resp->iovcnt = 0; resp->chunked_data_iov = 0; resp->chunked_total = 0; resp->skip = false; } void resp_add_iov(mc_resp *resp, const void *buf, int len) { assert(resp->iovcnt < MC_RESP_IOVCOUNT); int x = resp->iovcnt; resp->iov[x].iov_base = (void *)buf; resp->iov[x].iov_len = len; resp->iovcnt++; resp->tosend += len; } // Notes that an IOV should be handled as a chunked item header. // TODO: I'm hoping this isn't a permanent abstraction while I learn what the // API should be. void resp_add_chunked_iov(mc_resp *resp, const void *buf, int len) { resp->chunked_data_iov = resp->iovcnt; resp->chunked_total = len; resp_add_iov(resp, buf, len); } // resp_allocate and resp_free are a wrapper around read buffers which makes // read buffers the only network memory to track. // Normally this would be too excessive. In this case it allows end users to // track a single memory limit for ephemeral connection buffers. // Fancy bit twiddling tricks are avoided to help keep this straightforward. static mc_resp* resp_allocate(conn *c) { LIBEVENT_THREAD *th = c->thread; mc_resp *resp = NULL; mc_resp_bundle *b = th->open_bundle; if (b != NULL) { for (int i = 0; i < MAX_RESP_PER_BUNDLE; i++) { // loop around starting from the most likely to be free int x = (i + b->next_check) % MAX_RESP_PER_BUNDLE; if (b->r[x].free) { resp = &b->r[x]; b->next_check = x+1; break; } } if (resp != NULL) { b->refcount++; memset(resp, 0, sizeof(*resp)); resp->free = false; // redundant, for clarity. resp->bundle = b; if (b->refcount == MAX_RESP_PER_BUNDLE) { assert(b->prev == NULL); // We only allocate off the head. Assign new head. th->open_bundle = b->next; // Remove ourselves from the list. if (b->next) { b->next->prev = 0; b->next = 0; } } } } if (resp == NULL) { assert(th->open_bundle == NULL); b = do_cache_alloc(th->rbuf_cache); if (b) { THR_STATS_LOCK(th); th->stats.response_obj_bytes += READ_BUFFER_SIZE; THR_STATS_UNLOCK(th); b->next_check = 1; b->refcount = 1; for (int i = 0; i < MAX_RESP_PER_BUNDLE; i++) { b->r[i].free = true; } b->next = 0; b->prev = 0; th->open_bundle = b; resp = &b->r[0]; memset(resp, 0, sizeof(*resp)); resp->free = false; // redundant. for clarity. resp->bundle = b; } else { return NULL; } } return resp; } void resp_free(LIBEVENT_THREAD *th, mc_resp *resp) { mc_resp_bundle *b = resp->bundle; resp->free = true; b->refcount--; if (b->refcount == 0) { if (b == th->open_bundle && b->next == 0) { // This is the final bundle. Just hold and reuse to skip init loop assert(b->prev == 0); b->next_check = 0; } else { // Assert that we're either in the list or at the head. assert((b->next || b->prev) || b == th->open_bundle); // unlink from list. mc_resp_bundle **head = &th->open_bundle; if (*head == b) *head = b->next; // Not tracking the tail. assert(b->next != b && b->prev != b); if (b->next) b->next->prev = b->prev; if (b->prev) b->prev->next = b->next; // Now completely done with this buffer. do_cache_free(th->rbuf_cache, b); THR_STATS_LOCK(th); th->stats.response_obj_bytes -= READ_BUFFER_SIZE; THR_STATS_UNLOCK(th); } } else { mc_resp_bundle **head = &th->open_bundle; // NOTE: since we're not tracking tail, latest free ends up in head. if (b == th->open_bundle || (b->prev || b->next)) { // If we're already linked, leave it in place to save CPU. } else { // Non-zero refcount, need to link into the freelist. b->prev = 0; b->next = *head; if (b->next) b->next->prev = b; *head = b; } } THR_STATS_LOCK(th); th->stats.response_obj_count--; THR_STATS_UNLOCK(th); } bool resp_start(conn *c) { mc_resp *resp = resp_allocate(c); if (!resp) { THR_STATS_LOCK(c->thread); c->thread->stats.response_obj_oom++; THR_STATS_UNLOCK(c->thread); return false; } // handling the stats counters here to simplify testing THR_STATS_LOCK(c->thread); c->thread->stats.response_obj_count++; THR_STATS_UNLOCK(c->thread); if (!c->resp_head) { c->resp_head = resp; } if (!c->resp) { c->resp = resp; } else { c->resp->next = resp; c->resp = resp; } if (IS_UDP(c->transport)) { // need to hold on to some data for async responses. c->resp->request_id = c->request_id; c->resp->request_addr = c->request_addr; c->resp->request_addr_size = c->request_addr_size; } return true; } mc_resp *resp_start_unlinked(conn *c) { mc_resp *resp = resp_allocate(c); if (!resp) { THR_STATS_LOCK(c->thread); c->thread->stats.response_obj_oom++; THR_STATS_UNLOCK(c->thread); return false; } // handling the stats counters here to simplify testing THR_STATS_LOCK(c->thread); c->thread->stats.response_obj_count++; THR_STATS_UNLOCK(c->thread); if (IS_UDP(c->transport)) { // need to hold on to some data for async responses. c->resp->request_id = c->request_id; c->resp->request_addr = c->request_addr; c->resp->request_addr_size = c->request_addr_size; } return resp; } // returns next response in chain. mc_resp* resp_finish(conn *c, mc_resp *resp) { mc_resp *next = resp->next; if (resp->item) { // TODO: cache hash value in resp obj? item_remove(resp->item); resp->item = NULL; } if (resp->write_and_free) { free(resp->write_and_free); } if (resp->io_pending) { io_pending_t *io = resp->io_pending; // If we had a pending IO, tell it to internally clean up then return // the main object back to our thread cache. io->finalize_cb(io); do_cache_free(c->thread->io_cache, io); resp->io_pending = NULL; } if (c->resp_head == resp) { c->resp_head = next; } if (c->resp == resp) { c->resp = NULL; } resp_free(c->thread, resp); return next; } // tells if connection has a depth of response objects to process. bool resp_has_stack(conn *c) { return c->resp_head->next != NULL ? true : false; } void out_string(conn *c, const char *str) { size_t len; assert(c != NULL); mc_resp *resp = c->resp; // if response was original filled with something, but we're now writing // out an error or similar, have to reset the object first. // TODO: since this is often redundant with allocation, how many callers // are actually requiring it be reset? Can we fast test by just looking at // tosend and reset if nonzero? resp_reset(resp); if (c->noreply) { // TODO: just invalidate the response since nothing's been attempted // to send yet? resp->skip = true; if (settings.verbose > 1) fprintf(stderr, ">%d NOREPLY %s\n", c->sfd, str); conn_set_state(c, conn_new_cmd); return; } if (settings.verbose > 1) fprintf(stderr, ">%d %s\n", c->sfd, str); // Fill response object with static string. len = strlen(str); if ((len + 2) > WRITE_BUFFER_SIZE) { /* ought to be always enough. just fail for simplicity */ str = "SERVER_ERROR output line too long"; len = strlen(str); } memcpy(resp->wbuf, str, len); memcpy(resp->wbuf + len, "\r\n", 2); resp_add_iov(resp, resp->wbuf, len + 2); conn_set_state(c, conn_new_cmd); return; } // For metaget-style ASCII commands. Ignores noreply, ensuring clients see // protocol level errors. void out_errstring(conn *c, const char *str) { c->noreply = false; out_string(c, str); } /* * Outputs a protocol-specific "out of memory" error. For ASCII clients, * this is equivalent to out_string(). */ void out_of_memory(conn *c, char *ascii_error) { const static char error_prefix[] = "SERVER_ERROR "; const static int error_prefix_len = sizeof(error_prefix) - 1; if (c->protocol == binary_prot) { /* Strip off the generic error prefix; it's irrelevant in binary */ if (!strncmp(ascii_error, error_prefix, error_prefix_len)) { ascii_error += error_prefix_len; } write_bin_error(c, PROTOCOL_BINARY_RESPONSE_ENOMEM, ascii_error, 0); } else { out_string(c, ascii_error); } } static void append_bin_stats(const char *key, const uint16_t klen, const char *val, const uint32_t vlen, conn *c) { char *buf = c->stats.buffer + c->stats.offset; uint32_t bodylen = klen + vlen; protocol_binary_response_header header = { .response.magic = (uint8_t)PROTOCOL_BINARY_RES, .response.opcode = PROTOCOL_BINARY_CMD_STAT, .response.keylen = (uint16_t)htons(klen), .response.datatype = (uint8_t)PROTOCOL_BINARY_RAW_BYTES, .response.bodylen = htonl(bodylen), .response.opaque = c->opaque }; memcpy(buf, header.bytes, sizeof(header.response)); buf += sizeof(header.response); if (klen > 0) { memcpy(buf, key, klen); buf += klen; if (vlen > 0) { memcpy(buf, val, vlen); } } c->stats.offset += sizeof(header.response) + bodylen; } static void append_ascii_stats(const char *key, const uint16_t klen, const char *val, const uint32_t vlen, conn *c) { char *pos = c->stats.buffer + c->stats.offset; uint32_t nbytes = 0; int remaining = c->stats.size - c->stats.offset; int room = remaining - 1; if (klen == 0 && vlen == 0) { nbytes = snprintf(pos, room, "END\r\n"); } else if (vlen == 0) { nbytes = snprintf(pos, room, "STAT %s\r\n", key); } else { nbytes = snprintf(pos, room, "STAT %s %s\r\n", key, val); } c->stats.offset += nbytes; } static bool grow_stats_buf(conn *c, size_t needed) { size_t nsize = c->stats.size; size_t available = nsize - c->stats.offset; bool rv = true; /* Special case: No buffer -- need to allocate fresh */ if (c->stats.buffer == NULL) { nsize = 1024; available = c->stats.size = c->stats.offset = 0; } while (needed > available) { assert(nsize > 0); nsize = nsize << 1; available = nsize - c->stats.offset; } if (nsize != c->stats.size) { char *ptr = realloc(c->stats.buffer, nsize); if (ptr) { c->stats.buffer = ptr; c->stats.size = nsize; } else { STATS_LOCK(); stats.malloc_fails++; STATS_UNLOCK(); rv = false; } } return rv; } void append_stats(const char *key, const uint16_t klen, const char *val, const uint32_t vlen, const void *cookie) { /* value without a key is invalid */ if (klen == 0 && vlen > 0) { return; } conn *c = (conn*)cookie; if (c->protocol == binary_prot) { size_t needed = vlen + klen + sizeof(protocol_binary_response_header); if (!grow_stats_buf(c, needed)) { return; } append_bin_stats(key, klen, val, vlen, c); } else { size_t needed = vlen + klen + 10; // 10 == "STAT = \r\n" if (!grow_stats_buf(c, needed)) { return; } append_ascii_stats(key, klen, val, vlen, c); } assert(c->stats.offset <= c->stats.size); } static void reset_cmd_handler(conn *c) { c->cmd = -1; c->substate = bin_no_state; if (c->item != NULL) { // TODO: Any other way to get here? // SASL auth was mistakenly using it. Nothing else should? if (c->item_malloced) { free(c->item); c->item_malloced = false; } else { item_remove(c->item); } c->item = NULL; } if (c->rbytes > 0) { conn_set_state(c, conn_parse_cmd); } else if (c->resp_head) { conn_set_state(c, conn_mwrite); } else { conn_set_state(c, conn_waiting); } } static void complete_nread(conn *c) { assert(c != NULL); #ifdef PROXY assert(c->protocol == ascii_prot || c->protocol == binary_prot || c->protocol == proxy_prot); #else assert(c->protocol == ascii_prot || c->protocol == binary_prot); #endif if (c->protocol == ascii_prot) { complete_nread_ascii(c); } else if (c->protocol == binary_prot) { complete_nread_binary(c); #ifdef PROXY } else if (c->protocol == proxy_prot) { complete_nread_proxy(c); #endif } } /* Destination must always be chunked */ /* This should be part of item.c */ static int _store_item_copy_chunks(item *d_it, item *s_it, const int len) { item_chunk *dch = (item_chunk *) ITEM_schunk(d_it); /* Advance dch until we find free space */ while (dch->size == dch->used) { if (dch->next) { dch = dch->next; } else { break; } } if (s_it->it_flags & ITEM_CHUNKED) { int remain = len; item_chunk *sch = (item_chunk *) ITEM_schunk(s_it); int copied = 0; /* Fills dch's to capacity, not straight copy sch in case data is * being added or removed (ie append/prepend) */ while (sch && dch && remain) { assert(dch->used <= dch->size); int todo = (dch->size - dch->used < sch->used - copied) ? dch->size - dch->used : sch->used - copied; if (remain < todo) todo = remain; memcpy(dch->data + dch->used, sch->data + copied, todo); dch->used += todo; copied += todo; remain -= todo; assert(dch->used <= dch->size); if (dch->size == dch->used) { item_chunk *tch = do_item_alloc_chunk(dch, remain); if (tch) { dch = tch; } else { return -1; } } assert(copied <= sch->used); if (copied == sch->used) { copied = 0; sch = sch->next; } } /* assert that the destination had enough space for the source */ assert(remain == 0); } else { int done = 0; /* Fill dch's via a non-chunked item. */ while (len > done && dch) { int todo = (dch->size - dch->used < len - done) ? dch->size - dch->used : len - done; //assert(dch->size - dch->used != 0); memcpy(dch->data + dch->used, ITEM_data(s_it) + done, todo); done += todo; dch->used += todo; assert(dch->used <= dch->size); if (dch->size == dch->used) { item_chunk *tch = do_item_alloc_chunk(dch, len - done); if (tch) { dch = tch; } else { return -1; } } } assert(len == done); } return 0; } static int _store_item_copy_data(int comm, item *old_it, item *new_it, item *add_it) { if (comm == NREAD_APPEND || comm == NREAD_APPENDVIV) { if (new_it->it_flags & ITEM_CHUNKED) { if (_store_item_copy_chunks(new_it, old_it, old_it->nbytes - 2) == -1 || _store_item_copy_chunks(new_it, add_it, add_it->nbytes) == -1) { return -1; } } else { memcpy(ITEM_data(new_it), ITEM_data(old_it), old_it->nbytes); memcpy(ITEM_data(new_it) + old_it->nbytes - 2 /* CRLF */, ITEM_data(add_it), add_it->nbytes); } } else { /* NREAD_PREPEND */ if (new_it->it_flags & ITEM_CHUNKED) { if (_store_item_copy_chunks(new_it, add_it, add_it->nbytes - 2) == -1 || _store_item_copy_chunks(new_it, old_it, old_it->nbytes) == -1) { return -1; } } else { memcpy(ITEM_data(new_it), ITEM_data(add_it), add_it->nbytes); memcpy(ITEM_data(new_it) + add_it->nbytes - 2 /* CRLF */, ITEM_data(old_it), old_it->nbytes); } } return 0; } /* * Stores an item in the cache according to the semantics of one of the set * commands. Protected by the item lock. * * Returns the state of storage. */ enum store_item_type do_store_item(item *it, int comm, LIBEVENT_THREAD *t, const uint32_t hv, int *nbytes, uint64_t *cas, bool cas_stale) { char *key = ITEM_key(it); item *old_it = do_item_get(key, it->nkey, hv, t, DONT_UPDATE); enum store_item_type stored = NOT_STORED; enum cas_result { CAS_NONE, CAS_MATCH, CAS_BADVAL, CAS_STALE, CAS_MISS }; item *new_it = NULL; uint32_t flags; /* Do the CAS test up front so we can apply to all store modes */ enum cas_result cas_res = CAS_NONE; bool do_store = false; if (old_it != NULL) { // Most of the CAS work requires something to compare to. uint64_t it_cas = ITEM_get_cas(it); uint64_t old_cas = ITEM_get_cas(old_it); if (it_cas == 0) { cas_res = CAS_NONE; } else if (it_cas == old_cas) { cas_res = CAS_MATCH; } else if (cas_stale && it_cas < old_cas) { cas_res = CAS_STALE; } else { cas_res = CAS_BADVAL; } switch (comm) { case NREAD_ADD: /* add only adds a nonexistent item, but promote to head of LRU */ do_item_update(old_it); break; case NREAD_CAS: if (cas_res == CAS_MATCH) { // cas validates // it and old_it may belong to different classes. // I'm updating the stats for the one that's getting pushed out pthread_mutex_lock(&t->stats.mutex); t->stats.slab_stats[ITEM_clsid(old_it)].cas_hits++; pthread_mutex_unlock(&t->stats.mutex); do_store = true; } else if (cas_res == CAS_STALE) { // if we're allowed to set a stale value, CAS must be lower than // the current item's CAS. // This replaces the value, but should preserve TTL, and stale // item marker bit + token sent if exists. it->exptime = old_it->exptime; it->it_flags |= ITEM_STALE; if (old_it->it_flags & ITEM_TOKEN_SENT) { it->it_flags |= ITEM_TOKEN_SENT; } pthread_mutex_lock(&t->stats.mutex); t->stats.slab_stats[ITEM_clsid(old_it)].cas_hits++; pthread_mutex_unlock(&t->stats.mutex); do_store = true; } else { // NONE or BADVAL are the same for CAS cmd pthread_mutex_lock(&t->stats.mutex); t->stats.slab_stats[ITEM_clsid(old_it)].cas_badval++; pthread_mutex_unlock(&t->stats.mutex); if (settings.verbose > 1) { fprintf(stderr, "CAS: failure: expected %llu, got %llu\n", (unsigned long long)ITEM_get_cas(old_it), (unsigned long long)ITEM_get_cas(it)); } stored = EXISTS; } break; case NREAD_APPEND: case NREAD_PREPEND: case NREAD_APPENDVIV: case NREAD_PREPENDVIV: if (cas_res != CAS_NONE && cas_res != CAS_MATCH) { stored = EXISTS; break; } #ifdef EXTSTORE if ((old_it->it_flags & ITEM_HDR) != 0) { /* block append/prepend from working with extstore-d items. * leave response code to NOT_STORED default */ break; } #endif /* we have it and old_it here - alloc memory to hold both */ FLAGS_CONV(old_it, flags); new_it = do_item_alloc(key, it->nkey, flags, old_it->exptime, it->nbytes + old_it->nbytes - 2 /* CRLF */); // OOM trying to copy. if (new_it == NULL) break; /* copy data from it and old_it to new_it */ if (_store_item_copy_data(comm, old_it, new_it, it) == -1) { // failed data copy break; } else { // refcount of new_it is 1 here. will end up 2 after link. // it's original ref is managed outside of this function it = new_it; do_store = true; // Upstream final object size for meta if (nbytes != NULL) { *nbytes = it->nbytes; } } break; case NREAD_REPLACE: case NREAD_SET: do_store = true; break; } if (do_store) { STORAGE_delete(t->storage, old_it); item_replace(old_it, it, hv); stored = STORED; } do_item_remove(old_it); /* release our reference */ if (new_it != NULL) { // append/prepend end up with an extra reference for new_it. do_item_remove(new_it); } } else { /* No pre-existing item to replace or compare to. */ if (ITEM_get_cas(it) != 0) { /* Asked for a CAS match but nothing to compare it to. */ cas_res = CAS_MISS; } switch (comm) { case NREAD_ADD: case NREAD_SET: case NREAD_APPENDVIV: case NREAD_PREPENDVIV: do_store = true; break; case NREAD_CAS: // LRU expired stored = NOT_FOUND; pthread_mutex_lock(&t->stats.mutex); t->stats.cas_misses++; pthread_mutex_unlock(&t->stats.mutex); break; case NREAD_REPLACE: case NREAD_APPEND: case NREAD_PREPEND: /* Requires an existing item. */ break; } if (do_store) { do_item_link(it, hv); stored = STORED; } } if (stored == STORED && cas != NULL) { *cas = ITEM_get_cas(it); } LOGGER_LOG(t->l, LOG_MUTATIONS, LOGGER_ITEM_STORE, NULL, stored, comm, ITEM_key(it), it->nkey, it->nbytes, it->exptime, ITEM_clsid(it), t->cur_sfd); return stored; } /* set up a connection to write a buffer then free it, used for stats */ void write_and_free(conn *c, char *buf, int bytes) { if (buf) { mc_resp *resp = c->resp; resp->write_and_free = buf; resp_add_iov(resp, buf, bytes); conn_set_state(c, conn_new_cmd); } else { out_of_memory(c, "SERVER_ERROR out of memory writing stats"); } } void append_stat(const char *name, ADD_STAT add_stats, conn *c, const char *fmt, ...) { char val_str[STAT_VAL_LEN]; int vlen; va_list ap; assert(name); assert(add_stats); assert(c); assert(fmt); va_start(ap, fmt); vlen = vsnprintf(val_str, sizeof(val_str) - 1, fmt, ap); va_end(ap); add_stats(name, strlen(name), val_str, vlen, c); } /* return server specific stats only */ void server_stats(ADD_STAT add_stats, conn *c) { pid_t pid = getpid(); rel_time_t now = current_time; struct thread_stats thread_stats; threadlocal_stats_aggregate(&thread_stats); struct slab_stats slab_stats; slab_stats_aggregate(&thread_stats, &slab_stats); #ifndef WIN32 struct rusage usage; getrusage(RUSAGE_SELF, &usage); #endif /* !WIN32 */ STATS_LOCK(); APPEND_STAT("pid", "%lu", (long)pid); APPEND_STAT("uptime", "%u", now - ITEM_UPDATE_INTERVAL); APPEND_STAT("time", "%ld", now + (long)process_started); APPEND_STAT("version", "%s", VERSION); APPEND_STAT("libevent", "%s", event_get_version()); APPEND_STAT("pointer_size", "%d", (int)(8 * sizeof(void *))); #ifndef WIN32 append_stat("rusage_user", add_stats, c, "%ld.%06ld", (long)usage.ru_utime.tv_sec, (long)usage.ru_utime.tv_usec); append_stat("rusage_system", add_stats, c, "%ld.%06ld", (long)usage.ru_stime.tv_sec, (long)usage.ru_stime.tv_usec); #endif /* !WIN32 */ APPEND_STAT("max_connections", "%d", settings.maxconns); APPEND_STAT("curr_connections", "%llu", (unsigned long long)stats_state.curr_conns - 1); APPEND_STAT("total_connections", "%llu", (unsigned long long)stats.total_conns); if (settings.maxconns_fast) { APPEND_STAT("rejected_connections", "%llu", (unsigned long long)stats.rejected_conns); } APPEND_STAT("connection_structures", "%u", stats_state.conn_structs); APPEND_STAT("response_obj_oom", "%llu", (unsigned long long)thread_stats.response_obj_oom); APPEND_STAT("response_obj_count", "%llu", (unsigned long long)thread_stats.response_obj_count); APPEND_STAT("response_obj_bytes", "%llu", (unsigned long long)thread_stats.response_obj_bytes); APPEND_STAT("read_buf_count", "%llu", (unsigned long long)thread_stats.read_buf_count); APPEND_STAT("read_buf_bytes", "%llu", (unsigned long long)thread_stats.read_buf_bytes); APPEND_STAT("read_buf_bytes_free", "%llu", (unsigned long long)thread_stats.read_buf_bytes_free); APPEND_STAT("read_buf_oom", "%llu", (unsigned long long)thread_stats.read_buf_oom); APPEND_STAT("reserved_fds", "%u", stats_state.reserved_fds); #ifdef PROXY if (settings.proxy_enabled) { APPEND_STAT("proxy_conn_requests", "%llu", (unsigned long long)thread_stats.proxy_conn_requests); APPEND_STAT("proxy_conn_errors", "%llu", (unsigned long long)thread_stats.proxy_conn_errors); APPEND_STAT("proxy_conn_oom", "%llu", (unsigned long long)thread_stats.proxy_conn_oom); APPEND_STAT("proxy_req_active", "%llu", (unsigned long long)thread_stats.proxy_req_active); APPEND_STAT("proxy_await_active", "%llu", (unsigned long long)thread_stats.proxy_await_active); } #endif APPEND_STAT("cmd_get", "%llu", (unsigned long long)thread_stats.get_cmds); APPEND_STAT("cmd_set", "%llu", (unsigned long long)slab_stats.set_cmds); APPEND_STAT("cmd_flush", "%llu", (unsigned long long)thread_stats.flush_cmds); APPEND_STAT("cmd_touch", "%llu", (unsigned long long)thread_stats.touch_cmds); APPEND_STAT("cmd_meta", "%llu", (unsigned long long)thread_stats.meta_cmds); APPEND_STAT("get_hits", "%llu", (unsigned long long)slab_stats.get_hits); APPEND_STAT("get_misses", "%llu", (unsigned long long)thread_stats.get_misses); APPEND_STAT("get_expired", "%llu", (unsigned long long)thread_stats.get_expired); APPEND_STAT("get_flushed", "%llu", (unsigned long long)thread_stats.get_flushed); #ifdef EXTSTORE if (c->thread->storage) { APPEND_STAT("get_extstore", "%llu", (unsigned long long)thread_stats.get_extstore); APPEND_STAT("get_aborted_extstore", "%llu", (unsigned long long)thread_stats.get_aborted_extstore); APPEND_STAT("get_oom_extstore", "%llu", (unsigned long long)thread_stats.get_oom_extstore); APPEND_STAT("recache_from_extstore", "%llu", (unsigned long long)thread_stats.recache_from_extstore); APPEND_STAT("miss_from_extstore", "%llu", (unsigned long long)thread_stats.miss_from_extstore); APPEND_STAT("badcrc_from_extstore", "%llu", (unsigned long long)thread_stats.badcrc_from_extstore); } #endif APPEND_STAT("delete_misses", "%llu", (unsigned long long)thread_stats.delete_misses); APPEND_STAT("delete_hits", "%llu", (unsigned long long)slab_stats.delete_hits); APPEND_STAT("incr_misses", "%llu", (unsigned long long)thread_stats.incr_misses); APPEND_STAT("incr_hits", "%llu", (unsigned long long)slab_stats.incr_hits); APPEND_STAT("decr_misses", "%llu", (unsigned long long)thread_stats.decr_misses); APPEND_STAT("decr_hits", "%llu", (unsigned long long)slab_stats.decr_hits); APPEND_STAT("cas_misses", "%llu", (unsigned long long)thread_stats.cas_misses); APPEND_STAT("cas_hits", "%llu", (unsigned long long)slab_stats.cas_hits); APPEND_STAT("cas_badval", "%llu", (unsigned long long)slab_stats.cas_badval); APPEND_STAT("touch_hits", "%llu", (unsigned long long)slab_stats.touch_hits); APPEND_STAT("touch_misses", "%llu", (unsigned long long)thread_stats.touch_misses); APPEND_STAT("store_too_large", "%llu", (unsigned long long)thread_stats.store_too_large); APPEND_STAT("store_no_memory", "%llu", (unsigned long long)thread_stats.store_no_memory); APPEND_STAT("auth_cmds", "%llu", (unsigned long long)thread_stats.auth_cmds); APPEND_STAT("auth_errors", "%llu", (unsigned long long)thread_stats.auth_errors); if (settings.idle_timeout) { APPEND_STAT("idle_kicks", "%llu", (unsigned long long)thread_stats.idle_kicks); } APPEND_STAT("bytes_read", "%llu", (unsigned long long)thread_stats.bytes_read); APPEND_STAT("bytes_written", "%llu", (unsigned long long)thread_stats.bytes_written); APPEND_STAT("limit_maxbytes", "%llu", (unsigned long long)settings.maxbytes); APPEND_STAT("accepting_conns", "%u", stats_state.accepting_conns); APPEND_STAT("listen_disabled_num", "%llu", (unsigned long long)stats.listen_disabled_num); APPEND_STAT("time_in_listen_disabled_us", "%llu", stats.time_in_listen_disabled_us); APPEND_STAT("threads", "%d", settings.num_threads); APPEND_STAT("conn_yields", "%llu", (unsigned long long)thread_stats.conn_yields); APPEND_STAT("hash_power_level", "%u", stats_state.hash_power_level); APPEND_STAT("hash_bytes", "%llu", (unsigned long long)stats_state.hash_bytes); APPEND_STAT("hash_is_expanding", "%u", stats_state.hash_is_expanding); if (settings.slab_reassign) { APPEND_STAT("slab_reassign_rescues", "%llu", stats.slab_reassign_rescues); APPEND_STAT("slab_reassign_chunk_rescues", "%llu", stats.slab_reassign_chunk_rescues); APPEND_STAT("slab_reassign_evictions_nomem", "%llu", stats.slab_reassign_evictions_nomem); APPEND_STAT("slab_reassign_inline_reclaim", "%llu", stats.slab_reassign_inline_reclaim); APPEND_STAT("slab_reassign_busy_items", "%llu", stats.slab_reassign_busy_items); APPEND_STAT("slab_reassign_busy_deletes", "%llu", stats.slab_reassign_busy_deletes); APPEND_STAT("slab_reassign_running", "%u", stats_state.slab_reassign_running); APPEND_STAT("slabs_moved", "%llu", stats.slabs_moved); } if (settings.lru_crawler) { APPEND_STAT("lru_crawler_running", "%u", stats_state.lru_crawler_running); APPEND_STAT("lru_crawler_starts", "%u", stats.lru_crawler_starts); } if (settings.lru_maintainer_thread) { APPEND_STAT("lru_maintainer_juggles", "%llu", (unsigned long long)stats.lru_maintainer_juggles); } APPEND_STAT("malloc_fails", "%llu", (unsigned long long)stats.malloc_fails); APPEND_STAT("log_worker_dropped", "%llu", (unsigned long long)stats.log_worker_dropped); APPEND_STAT("log_worker_written", "%llu", (unsigned long long)stats.log_worker_written); APPEND_STAT("log_watcher_skipped", "%llu", (unsigned long long)stats.log_watcher_skipped); APPEND_STAT("log_watcher_sent", "%llu", (unsigned long long)stats.log_watcher_sent); APPEND_STAT("log_watchers", "%llu", (unsigned long long)stats_state.log_watchers); STATS_UNLOCK(); #ifdef EXTSTORE storage_stats(add_stats, c); #endif #ifdef PROXY proxy_stats(settings.proxy_ctx, add_stats, c); #endif #ifdef TLS if (settings.ssl_enabled) { if (settings.ssl_session_cache) { APPEND_STAT("ssl_new_sessions", "%llu", (unsigned long long)stats.ssl_new_sessions); } APPEND_STAT("ssl_handshake_errors", "%llu", (unsigned long long)stats.ssl_handshake_errors); APPEND_STAT("time_since_server_cert_refresh", "%u", now - settings.ssl_last_cert_refresh_time); } #endif APPEND_STAT("unexpected_napi_ids", "%llu", (unsigned long long)stats.unexpected_napi_ids); APPEND_STAT("round_robin_fallback", "%llu", (unsigned long long)stats.round_robin_fallback); } void process_stat_settings(ADD_STAT add_stats, void *c) { assert(add_stats); APPEND_STAT("maxbytes", "%llu", (unsigned long long)settings.maxbytes); APPEND_STAT("maxconns", "%d", settings.maxconns); APPEND_STAT("tcpport", "%d", settings.port); APPEND_STAT("udpport", "%d", settings.udpport); APPEND_STAT("inter", "%s", settings.inter ? settings.inter : "NULL"); APPEND_STAT("verbosity", "%d", settings.verbose); APPEND_STAT("oldest", "%lu", (unsigned long)settings.oldest_live); APPEND_STAT("evictions", "%s", settings.evict_to_free ? "on" : "off"); APPEND_STAT("domain_socket", "%s", settings.socketpath ? settings.socketpath : "NULL"); APPEND_STAT("umask", "%o", settings.access); APPEND_STAT("shutdown_command", "%s", settings.shutdown_command ? "yes" : "no"); APPEND_STAT("growth_factor", "%.2f", settings.factor); APPEND_STAT("chunk_size", "%d", settings.chunk_size); APPEND_STAT("num_threads", "%d", settings.num_threads); APPEND_STAT("num_threads_per_udp", "%d", settings.num_threads_per_udp); APPEND_STAT("stat_key_prefix", "%c", settings.prefix_delimiter); APPEND_STAT("detail_enabled", "%s", settings.detail_enabled ? "yes" : "no"); APPEND_STAT("reqs_per_event", "%d", settings.reqs_per_event); APPEND_STAT("cas_enabled", "%s", settings.use_cas ? "yes" : "no"); APPEND_STAT("tcp_backlog", "%d", settings.backlog); APPEND_STAT("binding_protocol", "%s", prot_text(settings.binding_protocol)); APPEND_STAT("auth_enabled_sasl", "%s", settings.sasl ? "yes" : "no"); APPEND_STAT("auth_enabled_ascii", "%s", settings.auth_file ? settings.auth_file : "no"); APPEND_STAT("item_size_max", "%d", settings.item_size_max); APPEND_STAT("maxconns_fast", "%s", settings.maxconns_fast ? "yes" : "no"); APPEND_STAT("hashpower_init", "%d", settings.hashpower_init); APPEND_STAT("slab_reassign", "%s", settings.slab_reassign ? "yes" : "no"); APPEND_STAT("slab_automove", "%d", settings.slab_automove); APPEND_STAT("slab_automove_ratio", "%.2f", settings.slab_automove_ratio); APPEND_STAT("slab_automove_window", "%u", settings.slab_automove_window); APPEND_STAT("slab_chunk_max", "%d", settings.slab_chunk_size_max); APPEND_STAT("lru_crawler", "%s", settings.lru_crawler ? "yes" : "no"); APPEND_STAT("lru_crawler_sleep", "%d", settings.lru_crawler_sleep); APPEND_STAT("lru_crawler_tocrawl", "%lu", (unsigned long)settings.lru_crawler_tocrawl); APPEND_STAT("tail_repair_time", "%d", settings.tail_repair_time); APPEND_STAT("flush_enabled", "%s", settings.flush_enabled ? "yes" : "no"); APPEND_STAT("dump_enabled", "%s", settings.dump_enabled ? "yes" : "no"); APPEND_STAT("hash_algorithm", "%s", settings.hash_algorithm); APPEND_STAT("lru_maintainer_thread", "%s", settings.lru_maintainer_thread ? "yes" : "no"); APPEND_STAT("lru_segmented", "%s", settings.lru_segmented ? "yes" : "no"); APPEND_STAT("hot_lru_pct", "%d", settings.hot_lru_pct); APPEND_STAT("warm_lru_pct", "%d", settings.warm_lru_pct); APPEND_STAT("hot_max_factor", "%.2f", settings.hot_max_factor); APPEND_STAT("warm_max_factor", "%.2f", settings.warm_max_factor); APPEND_STAT("temp_lru", "%s", settings.temp_lru ? "yes" : "no"); APPEND_STAT("temporary_ttl", "%u", settings.temporary_ttl); APPEND_STAT("idle_timeout", "%d", settings.idle_timeout); APPEND_STAT("watcher_logbuf_size", "%u", settings.logger_watcher_buf_size); APPEND_STAT("worker_logbuf_size", "%u", settings.logger_buf_size); APPEND_STAT("read_buf_mem_limit", "%u", settings.read_buf_mem_limit); APPEND_STAT("track_sizes", "%s", item_stats_sizes_status() ? "yes" : "no"); APPEND_STAT("inline_ascii_response", "%s", "no"); // setting is dead, cannot be yes. #ifdef HAVE_DROP_PRIVILEGES APPEND_STAT("drop_privileges", "%s", settings.drop_privileges ? "yes" : "no"); #endif #ifdef EXTSTORE APPEND_STAT("ext_item_size", "%u", settings.ext_item_size); APPEND_STAT("ext_item_age", "%u", settings.ext_item_age); APPEND_STAT("ext_low_ttl", "%u", settings.ext_low_ttl); APPEND_STAT("ext_recache_rate", "%u", settings.ext_recache_rate); APPEND_STAT("ext_wbuf_size", "%u", settings.ext_wbuf_size); APPEND_STAT("ext_compact_under", "%u", settings.ext_compact_under); APPEND_STAT("ext_drop_under", "%u", settings.ext_drop_under); APPEND_STAT("ext_max_sleep", "%u", settings.ext_max_sleep); APPEND_STAT("ext_max_frag", "%.2f", settings.ext_max_frag); APPEND_STAT("slab_automove_freeratio", "%.3f", settings.slab_automove_freeratio); APPEND_STAT("ext_drop_unread", "%s", settings.ext_drop_unread ? "yes" : "no"); #endif #ifdef TLS APPEND_STAT("ssl_enabled", "%s", settings.ssl_enabled ? "yes" : "no"); APPEND_STAT("ssl_chain_cert", "%s", settings.ssl_chain_cert); APPEND_STAT("ssl_key", "%s", settings.ssl_key); APPEND_STAT("ssl_verify_mode", "%d", settings.ssl_verify_mode); APPEND_STAT("ssl_keyformat", "%d", settings.ssl_keyformat); APPEND_STAT("ssl_ciphers", "%s", settings.ssl_ciphers ? settings.ssl_ciphers : "NULL"); APPEND_STAT("ssl_ca_cert", "%s", settings.ssl_ca_cert ? settings.ssl_ca_cert : "NULL"); APPEND_STAT("ssl_wbuf_size", "%u", settings.ssl_wbuf_size); APPEND_STAT("ssl_session_cache", "%s", settings.ssl_session_cache ? "yes" : "no"); APPEND_STAT("ssl_kernel_tls", "%s", settings.ssl_kernel_tls ? "yes" : "no"); APPEND_STAT("ssl_min_version", "%s", ssl_proto_text(settings.ssl_min_version)); #endif #ifdef PROXY APPEND_STAT("proxy_enabled", "%s", settings.proxy_enabled ? "yes" : "no"); APPEND_STAT("proxy_uring_enabled", "%s", settings.proxy_uring ? "yes" : "no"); #endif APPEND_STAT("num_napi_ids", "%s", settings.num_napi_ids); APPEND_STAT("memory_file", "%s", settings.memory_file); } static int nz_strcmp(int nzlength, const char *nz, const char *z) { int zlength=strlen(z); return (zlength == nzlength) && (strncmp(nz, z, zlength) == 0) ? 0 : -1; } bool get_stats(const char *stat_type, int nkey, ADD_STAT add_stats, void *c) { bool ret = true; if (add_stats != NULL) { if (!stat_type) { /* prepare general statistics for the engine */ STATS_LOCK(); APPEND_STAT("bytes", "%llu", (unsigned long long)stats_state.curr_bytes); APPEND_STAT("curr_items", "%llu", (unsigned long long)stats_state.curr_items); APPEND_STAT("total_items", "%llu", (unsigned long long)stats.total_items); STATS_UNLOCK(); APPEND_STAT("slab_global_page_pool", "%u", global_page_pool_size(NULL)); item_stats_totals(add_stats, c); } else if (nz_strcmp(nkey, stat_type, "items") == 0) { item_stats(add_stats, c); } else if (nz_strcmp(nkey, stat_type, "slabs") == 0) { slabs_stats(add_stats, c); } else if (nz_strcmp(nkey, stat_type, "sizes") == 0) { item_stats_sizes(add_stats, c); } else if (nz_strcmp(nkey, stat_type, "sizes_enable") == 0) { item_stats_sizes_enable(add_stats, c); } else if (nz_strcmp(nkey, stat_type, "sizes_disable") == 0) { item_stats_sizes_disable(add_stats, c); } else { ret = false; } } else { ret = false; } return ret; } static inline void get_conn_text(const conn *c, const int af, char* addr, struct sockaddr *sock_addr) { char addr_text[MAXPATHLEN]; addr_text[0] = '\0'; const char *protoname = "?"; unsigned short port = 0; switch (af) { case AF_INET: (void) inet_ntop(af, &((struct sockaddr_in *)sock_addr)->sin_addr, addr_text, sizeof(addr_text) - 1); port = ntohs(((struct sockaddr_in *)sock_addr)->sin_port); protoname = IS_UDP(c->transport) ? "udp" : "tcp"; break; case AF_INET6: addr_text[0] = '['; addr_text[1] = '\0'; if (inet_ntop(af, &((struct sockaddr_in6 *)sock_addr)->sin6_addr, addr_text + 1, sizeof(addr_text) - 2)) { strncat(addr_text, "]", 2); } port = ntohs(((struct sockaddr_in6 *)sock_addr)->sin6_port); protoname = IS_UDP(c->transport) ? "udp6" : "tcp6"; break; #ifndef DISABLE_UNIX_SOCKET case AF_UNIX: { size_t pathlen = 0; // this strncpy call originally could piss off an address // sanitizer; we supplied the size of the dest buf as a limiter, // but optimized versions of strncpy could read past the end of // *src while looking for a null terminator. Since buf and // sun_path here are both on the stack they could even overlap, // which is "undefined". In all OSS versions of strncpy I could // find this has no effect; it'll still only copy until the first null // terminator is found. Thus it's possible to get the OS to // examine past the end of sun_path but it's unclear to me if this // can cause any actual problem. // // We need a safe_strncpy util function but I'll punt on figuring // that out for now. pathlen = sizeof(((struct sockaddr_un *)sock_addr)->sun_path); if (MAXPATHLEN <= pathlen) { pathlen = MAXPATHLEN - 1; } strncpy(addr_text, ((struct sockaddr_un *)sock_addr)->sun_path, pathlen); addr_text[pathlen] = '\0'; protoname = "unix"; } break; #endif /* #ifndef DISABLE_UNIX_SOCKET */ } if (strlen(addr_text) < 2) { /* Most likely this is a connected UNIX-domain client which * has no peer socket address, but there's no portable way * to tell for sure. */ snprintf(addr_text, MAXPATHLEN, "", af); } if (port) { snprintf(addr, MAXPATHLEN + 11, "%s:%s:%u", protoname, addr_text, port); } else { snprintf(addr, MAXPATHLEN + 11, "%s:%s", protoname, addr_text); } } static void conn_to_str(const conn *c, char *addr, char *svr_addr) { if (!c) { memcpy(addr, "", 6); } else if (c->state == conn_closed) { memcpy(addr, "", 8); } else { struct sockaddr_in6 local_addr; struct sockaddr *sock_addr = (void *)&c->request_addr; /* For listen ports and idle UDP ports, show listen address */ if (c->state == conn_listening || (IS_UDP(c->transport) && c->state == conn_read)) { memset(&local_addr, 0, sizeof(local_addr)); socklen_t local_addr_len = sizeof(local_addr); if (getsockname(c->sfd, (struct sockaddr *)&local_addr, &local_addr_len) == 0) { sock_addr = (struct sockaddr *)&local_addr; } } get_conn_text(c, sock_addr->sa_family, addr, sock_addr); if (c->state != conn_listening && !(IS_UDP(c->transport) && c->state == conn_read)) { struct sockaddr_storage svr_sock_addr; memset(&svr_sock_addr, 0, sizeof(svr_sock_addr)); socklen_t svr_addr_len = sizeof(svr_sock_addr); getsockname(c->sfd, (struct sockaddr *)&svr_sock_addr, &svr_addr_len); get_conn_text(c, svr_sock_addr.ss_family, svr_addr, (struct sockaddr *)&svr_sock_addr); } } } void process_stats_conns(ADD_STAT add_stats, void *c) { int i; char key_str[STAT_KEY_LEN]; char val_str[STAT_VAL_LEN]; size_t extras_len = sizeof(":unix:") + sizeof("65535"); char addr[MAXPATHLEN + extras_len]; char svr_addr[MAXPATHLEN + extras_len]; memset(addr, 0, sizeof(addr)); memset(svr_addr, 0, sizeof(svr_addr)); int klen = 0, vlen = 0; assert(add_stats); for (i = 0; i < max_fds; i++) { if (conns[i]) { /* This is safe to do unlocked because conns are never freed; the * worst that'll happen will be a minor inconsistency in the * output -- not worth the complexity of the locking that'd be * required to prevent it. */ if (IS_UDP(conns[i]->transport)) { APPEND_NUM_STAT(i, "UDP", "%s", "UDP"); } if (conns[i]->state != conn_closed) { conn_to_str(conns[i], addr, svr_addr); APPEND_NUM_STAT(i, "addr", "%s", addr); if (conns[i]->state != conn_listening && !(IS_UDP(conns[i]->transport) && conns[i]->state == conn_read)) { APPEND_NUM_STAT(i, "listen_addr", "%s", svr_addr); } APPEND_NUM_STAT(i, "state", "%s", state_text(conns[i]->state)); APPEND_NUM_STAT(i, "secs_since_last_cmd", "%d", current_time - conns[i]->last_cmd_time); } } } } #define IT_REFCOUNT_LIMIT 60000 item* limited_get(const char *key, size_t nkey, LIBEVENT_THREAD *t, uint32_t exptime, bool should_touch, bool do_update, bool *overflow) { item *it; if (should_touch) { it = item_touch(key, nkey, exptime, t); } else { it = item_get(key, nkey, t, do_update); } if (it && it->refcount > IT_REFCOUNT_LIMIT) { item_remove(it); it = NULL; *overflow = true; } else { *overflow = false; } return it; } // Semantics are different than limited_get; since the item is returned // locked, caller can directly change what it needs. // though it might eventually be a better interface to sink it all into // items.c. item* limited_get_locked(const char *key, size_t nkey, LIBEVENT_THREAD *t, bool do_update, uint32_t *hv, bool *overflow) { item *it; it = item_get_locked(key, nkey, t, do_update, hv); if (it && it->refcount > IT_REFCOUNT_LIMIT) { do_item_remove(it); it = NULL; item_unlock(*hv); *overflow = true; } else { *overflow = false; } return it; } /* * adds a delta value to a numeric item. * * c connection requesting the operation * it item to adjust * incr true to increment value, false to decrement * delta amount to adjust value by * buf buffer for response string * * returns a response string to send back to the client. */ enum delta_result_type do_add_delta(LIBEVENT_THREAD *t, const char *key, const size_t nkey, const bool incr, const int64_t delta, char *buf, uint64_t *cas, const uint32_t hv, item **it_ret) { char *ptr; uint64_t value; int res; item *it; it = do_item_get(key, nkey, hv, t, DONT_UPDATE); if (!it) { return DELTA_ITEM_NOT_FOUND; } /* Can't delta zero byte values. 2-byte are the "\r\n" */ /* Also can't delta for chunked items. Too large to be a number */ #ifdef EXTSTORE if (it->nbytes <= 2 || (it->it_flags & (ITEM_CHUNKED|ITEM_HDR)) != 0) { #else if (it->nbytes <= 2 || (it->it_flags & (ITEM_CHUNKED)) != 0) { #endif do_item_remove(it); return NON_NUMERIC; } if (cas != NULL && *cas != 0 && ITEM_get_cas(it) != *cas) { do_item_remove(it); return DELTA_ITEM_CAS_MISMATCH; } ptr = ITEM_data(it); if (!safe_strtoull(ptr, &value)) { do_item_remove(it); return NON_NUMERIC; } if (incr) { value += delta; //MEMCACHED_COMMAND_INCR(c->sfd, ITEM_key(it), it->nkey, value); } else { if(delta > value) { value = 0; } else { value -= delta; } //MEMCACHED_COMMAND_DECR(c->sfd, ITEM_key(it), it->nkey, value); } pthread_mutex_lock(&t->stats.mutex); if (incr) { t->stats.slab_stats[ITEM_clsid(it)].incr_hits++; } else { t->stats.slab_stats[ITEM_clsid(it)].decr_hits++; } pthread_mutex_unlock(&t->stats.mutex); itoa_u64(value, buf); res = strlen(buf); /* refcount == 2 means we are the only ones holding the item, and it is * linked. We hold the item's lock in this function, so refcount cannot * increase. */ if (res + 2 <= it->nbytes && it->refcount == 2) { /* replace in-place */ /* When changing the value without replacing the item, we need to update the CAS on the existing item. */ /* We also need to fiddle it in the sizes tracker in case the tracking * was enabled at runtime, since it relies on the CAS value to know * whether to remove an item or not. */ item_stats_sizes_remove(it); ITEM_set_cas(it, (settings.use_cas) ? get_cas_id() : 0); item_stats_sizes_add(it); memcpy(ITEM_data(it), buf, res); memset(ITEM_data(it) + res, ' ', it->nbytes - res - 2); do_item_update(it); } else if (it->refcount > 1) { item *new_it; uint32_t flags; FLAGS_CONV(it, flags); new_it = do_item_alloc(ITEM_key(it), it->nkey, flags, it->exptime, res + 2); if (new_it == 0) { do_item_remove(it); return EOM; } memcpy(ITEM_data(new_it), buf, res); memcpy(ITEM_data(new_it) + res, "\r\n", 2); item_replace(it, new_it, hv); // Overwrite the older item's CAS with our new CAS since we're // returning the CAS of the old item below. ITEM_set_cas(it, (settings.use_cas) ? ITEM_get_cas(new_it) : 0); do_item_remove(new_it); /* release our reference */ } else { /* Should never get here. This means we somehow fetched an unlinked * item. TODO: Add a counter? */ if (settings.verbose) { fprintf(stderr, "Tried to do incr/decr on invalid item\n"); } if (it->refcount == 1) do_item_remove(it); return DELTA_ITEM_NOT_FOUND; } if (cas) { *cas = ITEM_get_cas(it); /* swap the incoming CAS value */ } if (it_ret != NULL) { *it_ret = it; } else { do_item_remove(it); /* release our reference */ } return OK; } static int try_read_command_negotiate(conn *c) { assert(c != NULL); assert(c->protocol == negotiating_prot); assert(c->rcurr <= (c->rbuf + c->rsize)); assert(c->rbytes > 0); if ((unsigned char)c->rbuf[0] == (unsigned char)PROTOCOL_BINARY_REQ) { c->protocol = binary_prot; c->try_read_command = try_read_command_binary; } else { // authentication doesn't work with negotiated protocol. c->protocol = ascii_prot; c->try_read_command = try_read_command_ascii; } if (settings.verbose > 1) { fprintf(stderr, "%d: Client using the %s protocol\n", c->sfd, prot_text(c->protocol)); } return c->try_read_command(c); } static int try_read_command_udp(conn *c) { assert(c != NULL); assert(c->rcurr <= (c->rbuf + c->rsize)); assert(c->rbytes > 0); if ((unsigned char)c->rbuf[0] == (unsigned char)PROTOCOL_BINARY_REQ) { c->protocol = binary_prot; return try_read_command_binary(c); } else { c->protocol = ascii_prot; return try_read_command_ascii(c); } } /* * read a UDP request. */ static enum try_read_result try_read_udp(conn *c) { int res; assert(c != NULL); c->request_addr_size = sizeof(c->request_addr); res = recvfrom(c->sfd, c->rbuf, c->rsize, 0, (struct sockaddr *)&c->request_addr, &c->request_addr_size); if (res > 8) { unsigned char *buf = (unsigned char *)c->rbuf; pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.bytes_read += res; pthread_mutex_unlock(&c->thread->stats.mutex); /* Beginning of UDP packet is the request ID; save it. */ c->request_id = buf[0] * 256 + buf[1]; /* If this is a multi-packet request, drop it. */ if (buf[4] != 0 || buf[5] != 1) { return READ_NO_DATA_RECEIVED; } /* Don't care about any of the rest of the header. */ res -= 8; memmove(c->rbuf, c->rbuf + 8, res); c->rbytes = res; c->rcurr = c->rbuf; return READ_DATA_RECEIVED; } return READ_NO_DATA_RECEIVED; } /* * read from network as much as we can, handle buffer overflow and connection * close. * before reading, move the remaining incomplete fragment of a command * (if any) to the beginning of the buffer. * * To protect us from someone flooding a connection with bogus data causing * the connection to eat up all available memory, break out and start looking * at the data I've got after a number of reallocs... * * @return enum try_read_result */ static enum try_read_result try_read_network(conn *c) { enum try_read_result gotdata = READ_NO_DATA_RECEIVED; int res; int num_allocs = 0; assert(c != NULL); if (c->rcurr != c->rbuf) { if (c->rbytes != 0) /* otherwise there's nothing to copy */ memmove(c->rbuf, c->rcurr, c->rbytes); c->rcurr = c->rbuf; } while (1) { // TODO: move to rbuf_* func? if (c->rbytes >= c->rsize && c->rbuf_malloced) { if (num_allocs == 4) { return gotdata; } ++num_allocs; char *new_rbuf = realloc(c->rbuf, c->rsize * 2); if (!new_rbuf) { STATS_LOCK(); stats.malloc_fails++; STATS_UNLOCK(); if (settings.verbose > 0) { fprintf(stderr, "Couldn't realloc input buffer\n"); } c->rbytes = 0; /* ignore what we read */ out_of_memory(c, "SERVER_ERROR out of memory reading request"); c->close_after_write = true; return READ_MEMORY_ERROR; } c->rcurr = c->rbuf = new_rbuf; c->rsize *= 2; } int avail = c->rsize - c->rbytes; res = c->read(c, c->rbuf + c->rbytes, avail); if (res > 0) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.bytes_read += res; pthread_mutex_unlock(&c->thread->stats.mutex); gotdata = READ_DATA_RECEIVED; c->rbytes += res; if (res == avail && c->rbuf_malloced) { // Resize rbuf and try a few times if huge ascii multiget. continue; } else { break; } } if (res == 0) { c->close_reason = NORMAL_CLOSE; return READ_ERROR; } if (res == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK) { break; } return READ_ERROR; } } return gotdata; } static bool update_event(conn *c, const int new_flags) { assert(c != NULL); struct event_base *base = c->event.ev_base; if (c->ev_flags == new_flags) return true; if (event_del(&c->event) == -1) return false; event_set(&c->event, c->sfd, new_flags, event_handler, (void *)c); event_base_set(base, &c->event); c->ev_flags = new_flags; if (event_add(&c->event, 0) == -1) return false; return true; } /* * Sets whether we are listening for new connections or not. */ void do_accept_new_conns(const bool do_accept) { conn *next; for (next = listen_conn; next; next = next->next) { if (do_accept) { update_event(next, EV_READ | EV_PERSIST); if (listen(next->sfd, settings.backlog) != 0) { perror("listen"); } } else { update_event(next, 0); if (listen(next->sfd, 0) != 0) { perror("listen"); } } } if (do_accept) { struct timeval maxconns_exited; uint64_t elapsed_us; gettimeofday(&maxconns_exited,NULL); STATS_LOCK(); elapsed_us = (maxconns_exited.tv_sec - stats.maxconns_entered.tv_sec) * 1000000 + (maxconns_exited.tv_usec - stats.maxconns_entered.tv_usec); stats.time_in_listen_disabled_us += elapsed_us; stats_state.accepting_conns = true; STATS_UNLOCK(); } else { STATS_LOCK(); stats_state.accepting_conns = false; gettimeofday(&stats.maxconns_entered,NULL); stats.listen_disabled_num++; STATS_UNLOCK(); allow_new_conns = false; maxconns_handler(-42, 0, 0); } } #define TRANSMIT_ONE_RESP true #define TRANSMIT_ALL_RESP false static int _transmit_pre(conn *c, struct iovec *iovs, int iovused, bool one_resp) { mc_resp *resp = c->resp_head; while (resp && iovused + resp->iovcnt < IOV_MAX-1) { if (resp->skip) { // Don't actually unchain the resp obj here since it's singly-linked. // Just let the post function handle it linearly. resp = resp->next; continue; } if (resp->chunked_data_iov) { // Handle chunked items specially. // They spend much more time in send so we can be a bit wasteful // in rebuilding iovecs for them. item_chunk *ch = (item_chunk *)ITEM_schunk((item *)resp->iov[resp->chunked_data_iov].iov_base); int x; for (x = 0; x < resp->iovcnt; x++) { // This iov is tracking how far we've copied so far. if (x == resp->chunked_data_iov) { int done = resp->chunked_total - resp->iov[x].iov_len; // Start from the len to allow binprot to cut the \r\n int todo = resp->iov[x].iov_len; while (ch && todo > 0 && iovused < IOV_MAX-1) { int skip = 0; if (!ch->used) { ch = ch->next; continue; } // Skip parts we've already sent. if (done >= ch->used) { done -= ch->used; ch = ch->next; continue; } else if (done) { skip = done; done = 0; } iovs[iovused].iov_base = ch->data + skip; // Stupid binary protocol makes this go negative. iovs[iovused].iov_len = ch->used - skip > todo ? todo : ch->used - skip; iovused++; todo -= ch->used - skip; ch = ch->next; } } else { iovs[iovused].iov_base = resp->iov[x].iov_base; iovs[iovused].iov_len = resp->iov[x].iov_len; iovused++; } if (iovused >= IOV_MAX-1) break; } } else { memcpy(&iovs[iovused], resp->iov, sizeof(struct iovec)*resp->iovcnt); iovused += resp->iovcnt; } // done looking at first response, walk down the chain. resp = resp->next; // used for UDP mode: UDP cannot send multiple responses per packet. if (one_resp) break; } return iovused; } /* * Decrements and completes responses based on how much data was transmitted. * Takes the connection and current result bytes. */ static void _transmit_post(conn *c, ssize_t res) { // We've written some of the data. Remove the completed // responses from the list of pending writes. mc_resp *resp = c->resp_head; while (resp) { int x; if (resp->skip) { resp = resp_finish(c, resp); continue; } // fastpath check. all small responses should cut here. if (res >= resp->tosend) { res -= resp->tosend; resp = resp_finish(c, resp); continue; } // it's fine to re-check iov's that were zeroed out before. for (x = 0; x < resp->iovcnt; x++) { struct iovec *iov = &resp->iov[x]; if (res >= iov->iov_len) { resp->tosend -= iov->iov_len; res -= iov->iov_len; iov->iov_len = 0; } else { // Dumb special case for chunked items. Currently tracking // where to inject the chunked item via iov_base. // Extra not-great since chunked items can't be the first // index, so we have to check for non-zero c_d_iov first. if (!resp->chunked_data_iov || x != resp->chunked_data_iov) { iov->iov_base = (char *)iov->iov_base + res; } iov->iov_len -= res; resp->tosend -= res; res = 0; break; } } // are we done with this response object? if (resp->tosend == 0) { resp = resp_finish(c, resp); } else { // Jammed up here. This is the new head. break; } } } /* * Transmit the next chunk of data from our list of msgbuf structures. * * Returns: * TRANSMIT_COMPLETE All done writing. * TRANSMIT_INCOMPLETE More data remaining to write. * TRANSMIT_SOFT_ERROR Can't write any more right now. * TRANSMIT_HARD_ERROR Can't write (c->state is set to conn_closing) */ static enum transmit_result transmit(conn *c) { assert(c != NULL); struct iovec iovs[IOV_MAX]; struct msghdr msg; int iovused = 0; // init the msg. memset(&msg, 0, sizeof(struct msghdr)); msg.msg_iov = iovs; iovused = _transmit_pre(c, iovs, iovused, TRANSMIT_ALL_RESP); if (iovused == 0) { // Avoid the syscall if we're only handling a noreply. // Return the response object. _transmit_post(c, 0); return TRANSMIT_COMPLETE; } // Alright, send. ssize_t res; msg.msg_iovlen = iovused; res = c->sendmsg(c, &msg, 0); if (res >= 0) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.bytes_written += res; pthread_mutex_unlock(&c->thread->stats.mutex); // Decrement any partial IOV's and complete any finished resp's. _transmit_post(c, res); if (c->resp_head) { return TRANSMIT_INCOMPLETE; } else { return TRANSMIT_COMPLETE; } } if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) { if (!update_event(c, EV_WRITE | EV_PERSIST)) { if (settings.verbose > 0) fprintf(stderr, "Couldn't update event\n"); conn_set_state(c, conn_closing); return TRANSMIT_HARD_ERROR; } return TRANSMIT_SOFT_ERROR; } /* if res == -1 and error is not EAGAIN or EWOULDBLOCK, we have a real error, on which we close the connection */ if (settings.verbose > 0) perror("Failed to write, and not due to blocking"); conn_set_state(c, conn_closing); return TRANSMIT_HARD_ERROR; } static void build_udp_header(unsigned char *hdr, mc_resp *resp) { // We need to communicate the total number of packets // If this isn't set, it's the first time this response is building a udp // header, so "tosend" must be static. if (!resp->udp_total) { uint32_t total; total = resp->tosend / UDP_DATA_SIZE; if (resp->tosend % UDP_DATA_SIZE) total++; // The spec doesn't really say what we should do here. It's _probably_ // better to bail out? if (total > USHRT_MAX) { total = USHRT_MAX; } resp->udp_total = total; } // TODO: why wasn't this hto*'s and casts? // this ends up sending UDP hdr data specifically in host byte order. *hdr++ = resp->request_id / 256; *hdr++ = resp->request_id % 256; *hdr++ = resp->udp_sequence / 256; *hdr++ = resp->udp_sequence % 256; *hdr++ = resp->udp_total / 256; *hdr++ = resp->udp_total % 256; *hdr++ = 0; *hdr++ = 0; resp->udp_sequence++; } /* * UDP specific transmit function. Uses its own function rather than check * IS_UDP() five times. If we ever implement sendmmsg or similar support they * will diverge even more. * Does not use TLS. * * Returns: * TRANSMIT_COMPLETE All done writing. * TRANSMIT_INCOMPLETE More data remaining to write. * TRANSMIT_SOFT_ERROR Can't write any more right now. * TRANSMIT_HARD_ERROR Can't write (c->state is set to conn_closing) */ static enum transmit_result transmit_udp(conn *c) { assert(c != NULL); struct iovec iovs[IOV_MAX]; struct msghdr msg; mc_resp *resp; int iovused = 0; unsigned char udp_hdr[UDP_HEADER_SIZE]; // We only send one UDP packet per call (ugh), so we can only operate on a // single response at a time. resp = c->resp_head; if (!resp) { return TRANSMIT_COMPLETE; } if (resp->skip) { resp = resp_finish(c, resp); return TRANSMIT_INCOMPLETE; } // clear the message and initialize it. memset(&msg, 0, sizeof(struct msghdr)); msg.msg_iov = iovs; // the UDP source to return to. msg.msg_name = &resp->request_addr; msg.msg_namelen = resp->request_addr_size; // First IOV is the custom UDP header. iovs[0].iov_base = (void *)udp_hdr; iovs[0].iov_len = UDP_HEADER_SIZE; build_udp_header(udp_hdr, resp); iovused++; // Fill the IOV's the standard way. // TODO: might get a small speedup if we let it break early with a length // limit. iovused = _transmit_pre(c, iovs, iovused, TRANSMIT_ONE_RESP); // Clip the IOV's to the max UDP packet size. // If we add support for send_mmsg, this can be where we split msg's. { int x = 0; int len = 0; for (x = 0; x < iovused; x++) { if (len + iovs[x].iov_len >= UDP_MAX_PAYLOAD_SIZE) { iovs[x].iov_len = UDP_MAX_PAYLOAD_SIZE - len; x++; break; } else { len += iovs[x].iov_len; } } iovused = x; } ssize_t res; msg.msg_iovlen = iovused; // NOTE: uses system sendmsg since we have no support for indirect UDP. res = sendmsg(c->sfd, &msg, 0); if (res >= 0) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.bytes_written += res; pthread_mutex_unlock(&c->thread->stats.mutex); // Ignore the header size from forwarding the IOV's res -= UDP_HEADER_SIZE; // Decrement any partial IOV's and complete any finished resp's. _transmit_post(c, res); if (c->resp_head) { return TRANSMIT_INCOMPLETE; } else { return TRANSMIT_COMPLETE; } } if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) { if (!update_event(c, EV_WRITE | EV_PERSIST)) { if (settings.verbose > 0) fprintf(stderr, "Couldn't update event\n"); conn_set_state(c, conn_closing); return TRANSMIT_HARD_ERROR; } return TRANSMIT_SOFT_ERROR; } /* if res == -1 and error is not EAGAIN or EWOULDBLOCK, we have a real error, on which we close the connection */ if (settings.verbose > 0) perror("Failed to write, and not due to blocking"); conn_set_state(c, conn_read); return TRANSMIT_HARD_ERROR; } /* Does a looped read to fill data chunks */ /* TODO: restrict number of times this can loop. * Also, benchmark using readv's. */ static int read_into_chunked_item(conn *c) { int total = 0; int res; assert(c->rcurr != c->ritem); while (c->rlbytes > 0) { item_chunk *ch = (item_chunk *)c->ritem; if (ch->size == ch->used) { // FIXME: ch->next is currently always 0. remove this? if (ch->next) { c->ritem = (char *) ch->next; } else { /* Allocate next chunk. Binary protocol needs 2b for \r\n */ c->ritem = (char *) do_item_alloc_chunk(ch, c->rlbytes + ((c->protocol == binary_prot) ? 2 : 0)); if (!c->ritem) { // We failed an allocation. Let caller handle cleanup. total = -2; break; } // ritem has new chunk, restart the loop. continue; //assert(c->rlbytes == 0); } } int unused = ch->size - ch->used; /* first check if we have leftovers in the conn_read buffer */ if (c->rbytes > 0) { total = 0; int tocopy = c->rbytes > c->rlbytes ? c->rlbytes : c->rbytes; tocopy = tocopy > unused ? unused : tocopy; if (c->ritem != c->rcurr) { memmove(ch->data + ch->used, c->rcurr, tocopy); } total += tocopy; c->rlbytes -= tocopy; c->rcurr += tocopy; c->rbytes -= tocopy; ch->used += tocopy; if (c->rlbytes == 0) { break; } } else { /* now try reading from the socket */ res = c->read(c, ch->data + ch->used, (unused > c->rlbytes ? c->rlbytes : unused)); if (res > 0) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.bytes_read += res; pthread_mutex_unlock(&c->thread->stats.mutex); ch->used += res; total += res; c->rlbytes -= res; } else { /* Reset total to the latest result so caller can handle it */ total = res; break; } } } /* At some point I will be able to ditch the \r\n from item storage and remove all of these kludges. The above binprot check ensures inline space for \r\n, but if we do exactly enough allocs there will be no additional chunk for \r\n. */ if (c->rlbytes == 0 && c->protocol == binary_prot && total >= 0) { item_chunk *ch = (item_chunk *)c->ritem; if (ch->size - ch->used < 2) { c->ritem = (char *) do_item_alloc_chunk(ch, 2); if (!c->ritem) { total = -2; } } } return total; } static void drive_machine(conn *c) { bool stop = false; int sfd; socklen_t addrlen; struct sockaddr_storage addr; int nreqs = settings.reqs_per_event; int res; const char *str; #ifdef HAVE_ACCEPT4 static int use_accept4 = 1; #else static int use_accept4 = 0; #endif assert(c != NULL); while (!stop) { switch(c->state) { case conn_listening: addrlen = sizeof(addr); #ifdef HAVE_ACCEPT4 if (use_accept4) { sfd = accept4(c->sfd, (struct sockaddr *)&addr, &addrlen, SOCK_NONBLOCK); } else { sfd = accept(c->sfd, (struct sockaddr *)&addr, &addrlen); } #else sfd = accept(c->sfd, (struct sockaddr *)&addr, &addrlen); #endif if (sfd == -1) { if (use_accept4 && errno == ENOSYS) { use_accept4 = 0; continue; } perror(use_accept4 ? "accept4()" : "accept()"); if (errno == EAGAIN || errno == EWOULDBLOCK) { /* these are transient, so don't log anything */ stop = true; } else if (errno == EMFILE) { if (settings.verbose > 0) fprintf(stderr, "Too many open connections\n"); accept_new_conns(false); stop = true; } else { perror("accept()"); stop = true; } break; } if (!use_accept4) { if (fcntl(sfd, F_SETFL, fcntl(sfd, F_GETFL) | O_NONBLOCK) < 0) { perror("setting O_NONBLOCK"); close(sfd); break; } } bool reject; if (settings.maxconns_fast) { reject = sfd >= settings.maxconns - 1; if (reject) { STATS_LOCK(); stats.rejected_conns++; STATS_UNLOCK(); } } else { reject = false; } if (reject) { str = "ERROR Too many open connections\r\n"; res = write(sfd, str, strlen(str)); close(sfd); } else { void *ssl_v = NULL; #ifdef TLS SSL *ssl = NULL; if (c->ssl_enabled) { assert(IS_TCP(c->transport) && settings.ssl_enabled); if (settings.ssl_ctx == NULL) { if (settings.verbose) { fprintf(stderr, "SSL context is not initialized\n"); } close(sfd); break; } SSL_LOCK(); ssl = SSL_new(settings.ssl_ctx); SSL_UNLOCK(); if (ssl == NULL) { if (settings.verbose) { fprintf(stderr, "Failed to created the SSL object\n"); } close(sfd); break; } SSL_set_fd(ssl, sfd); int ret = SSL_accept(ssl); if (ret <= 0) { int err = SSL_get_error(ssl, ret); if (err == SSL_ERROR_SYSCALL || err == SSL_ERROR_SSL) { if (settings.verbose) { fprintf(stderr, "SSL connection failed with error code : %d : %s\n", err, strerror(errno)); } SSL_free(ssl); close(sfd); STATS_LOCK(); stats.ssl_handshake_errors++; STATS_UNLOCK(); break; } } } ssl_v = (void*) ssl; #endif dispatch_conn_new(sfd, conn_new_cmd, EV_READ | EV_PERSIST, READ_BUFFER_CACHED, c->transport, ssl_v, c->tag, c->protocol); } stop = true; break; case conn_waiting: rbuf_release(c); if (!update_event(c, EV_READ | EV_PERSIST)) { if (settings.verbose > 0) fprintf(stderr, "Couldn't update event\n"); conn_set_state(c, conn_closing); break; } conn_set_state(c, conn_read); stop = true; break; case conn_read: if (!IS_UDP(c->transport)) { // Assign a read buffer if necessary. if (!rbuf_alloc(c)) { // TODO: Some way to allow for temporary failures. conn_set_state(c, conn_closing); break; } res = try_read_network(c); } else { // UDP connections always have a static buffer. res = try_read_udp(c); } switch (res) { case READ_NO_DATA_RECEIVED: conn_set_state(c, conn_waiting); break; case READ_DATA_RECEIVED: conn_set_state(c, conn_parse_cmd); break; case READ_ERROR: conn_set_state(c, conn_closing); break; case READ_MEMORY_ERROR: /* Failed to allocate more memory */ /* State already set by try_read_network */ break; } break; case conn_parse_cmd: c->noreply = false; if (c->try_read_command(c) == 0) { /* we need more data! */ if (c->resp_head) { // Buffered responses waiting, flush in the meantime. conn_set_state(c, conn_mwrite); } else { conn_set_state(c, conn_waiting); } } break; case conn_new_cmd: /* Only process nreqs at a time to avoid starving other connections */ --nreqs; if (nreqs >= 0) { reset_cmd_handler(c); } else if (c->resp_head) { // flush response pipe on yield. conn_set_state(c, conn_mwrite); } else { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.conn_yields++; pthread_mutex_unlock(&c->thread->stats.mutex); if (c->rbytes > 0) { /* We have already read in data into the input buffer, so libevent will most likely not signal read events on the socket (unless more data is available. As a hack we should just put in a request to write data, because that should be possible ;-) */ if (!update_event(c, EV_WRITE | EV_PERSIST)) { if (settings.verbose > 0) fprintf(stderr, "Couldn't update event\n"); conn_set_state(c, conn_closing); break; } } stop = true; } break; case conn_nread: if (c->rlbytes == 0) { complete_nread(c); break; } /* Check if rbytes < 0, to prevent crash */ if (c->rlbytes < 0) { if (settings.verbose) { fprintf(stderr, "Invalid rlbytes to read: len %d\n", c->rlbytes); } conn_set_state(c, conn_closing); break; } if (c->item_malloced || ((((item *)c->item)->it_flags & ITEM_CHUNKED) == 0) ) { /* first check if we have leftovers in the conn_read buffer */ if (c->rbytes > 0) { int tocopy = c->rbytes > c->rlbytes ? c->rlbytes : c->rbytes; memmove(c->ritem, c->rcurr, tocopy); c->ritem += tocopy; c->rlbytes -= tocopy; c->rcurr += tocopy; c->rbytes -= tocopy; if (c->rlbytes == 0) { break; } } /* now try reading from the socket */ res = c->read(c, c->ritem, c->rlbytes); if (res > 0) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.bytes_read += res; pthread_mutex_unlock(&c->thread->stats.mutex); if (c->rcurr == c->ritem) { c->rcurr += res; } c->ritem += res; c->rlbytes -= res; break; } } else { res = read_into_chunked_item(c); if (res > 0) break; } if (res == 0) { /* end of stream */ c->close_reason = NORMAL_CLOSE; conn_set_state(c, conn_closing); break; } if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) { if (!update_event(c, EV_READ | EV_PERSIST)) { if (settings.verbose > 0) fprintf(stderr, "Couldn't update event\n"); conn_set_state(c, conn_closing); break; } stop = true; break; } /* Memory allocation failure */ if (res == -2) { out_of_memory(c, "SERVER_ERROR Out of memory during read"); c->sbytes = c->rlbytes; conn_set_state(c, conn_swallow); // Ensure this flag gets cleared. It gets killed on conn_new() // so any conn_closing is fine, calling complete_nread is // fine. This swallow semms to be the only other case. c->set_stale = false; c->mset_res = false; break; } /* otherwise we have a real error, on which we close the connection */ if (settings.verbose > 0) { fprintf(stderr, "Failed to read, and not due to blocking:\n" "errno: %d %s \n" "rcurr=%p ritem=%p rbuf=%p rlbytes=%d rsize=%d\n", errno, strerror(errno), (void *)c->rcurr, (void *)c->ritem, (void *)c->rbuf, (int)c->rlbytes, (int)c->rsize); } conn_set_state(c, conn_closing); break; case conn_swallow: /* we are reading sbytes and throwing them away */ if (c->sbytes <= 0) { conn_set_state(c, conn_new_cmd); break; } /* first check if we have leftovers in the conn_read buffer */ if (c->rbytes > 0) { int tocopy = c->rbytes > c->sbytes ? c->sbytes : c->rbytes; c->sbytes -= tocopy; c->rcurr += tocopy; c->rbytes -= tocopy; break; } /* now try reading from the socket */ res = c->read(c, c->rbuf, c->rsize > c->sbytes ? c->sbytes : c->rsize); if (res > 0) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.bytes_read += res; pthread_mutex_unlock(&c->thread->stats.mutex); c->sbytes -= res; break; } if (res == 0) { /* end of stream */ c->close_reason = NORMAL_CLOSE; conn_set_state(c, conn_closing); break; } if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) { if (!update_event(c, EV_READ | EV_PERSIST)) { if (settings.verbose > 0) fprintf(stderr, "Couldn't update event\n"); conn_set_state(c, conn_closing); break; } stop = true; break; } /* otherwise we have a real error, on which we close the connection */ if (settings.verbose > 0) fprintf(stderr, "Failed to read, and not due to blocking\n"); conn_set_state(c, conn_closing); break; case conn_write: case conn_mwrite: /* have side IO's that must process before transmit() can run. * remove the connection from the worker thread and dispatch the * IO queue */ assert(c->io_queues_submitted == 0); for (io_queue_t *q = c->io_queues; q->type != IO_QUEUE_NONE; q++) { if (q->stack_ctx != NULL) { io_queue_cb_t *qcb = thread_io_queue_get(c->thread, q->type); qcb->submit_cb(q); c->io_queues_submitted++; } } if (c->io_queues_submitted != 0) { conn_set_state(c, conn_io_queue); event_del(&c->event); stop = true; break; } switch (!IS_UDP(c->transport) ? transmit(c) : transmit_udp(c)) { case TRANSMIT_COMPLETE: if (c->state == conn_mwrite) { // Free up IO wraps and any half-uploaded items. conn_release_items(c); conn_set_state(c, conn_new_cmd); if (c->close_after_write) { conn_set_state(c, conn_closing); } } else { if (settings.verbose > 0) fprintf(stderr, "Unexpected state %d\n", c->state); conn_set_state(c, conn_closing); } break; case TRANSMIT_INCOMPLETE: case TRANSMIT_HARD_ERROR: break; /* Continue in state machine. */ case TRANSMIT_SOFT_ERROR: stop = true; break; } break; case conn_closing: if (IS_UDP(c->transport)) conn_cleanup(c); else conn_close(c); stop = true; break; case conn_closed: /* This only happens if dormando is an idiot. */ abort(); break; case conn_watch: /* We handed off our connection to the logger thread. */ stop = true; break; case conn_io_queue: /* Complete our queued IO's from within the worker thread. */ conn_set_state(c, conn_mwrite); break; case conn_max_state: assert(false); break; } } return; } void event_handler(const evutil_socket_t fd, const short which, void *arg) { conn *c; c = (conn *)arg; assert(c != NULL); c->which = which; /* sanity */ if (fd != c->sfd) { if (settings.verbose > 0) fprintf(stderr, "Catastrophic: event fd doesn't match conn fd!\n"); conn_close(c); return; } drive_machine(c); /* wait for next event */ return; } static int new_socket(struct addrinfo *ai) { int sfd; int flags; if ((sfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)) == -1) { return -1; } if ((flags = fcntl(sfd, F_GETFL, 0)) < 0 || fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) { perror("setting O_NONBLOCK"); close(sfd); return -1; } return sfd; } /* * Sets a socket's send buffer size to the maximum allowed by the system. */ static void maximize_sndbuf(const int sfd) { socklen_t intsize = sizeof(int); int last_good = 0; int min, max, avg; int old_size; /* Start with the default size. */ #ifdef _WIN32 if (getsockopt((SOCKET)sfd, SOL_SOCKET, SO_SNDBUF, (char *)&old_size, &intsize) != 0) { #else if (getsockopt(sfd, SOL_SOCKET, SO_SNDBUF, &old_size, &intsize) != 0) { #endif /* #ifdef _WIN32 */ if (settings.verbose > 0) perror("getsockopt(SO_SNDBUF)"); return; } /* Binary-search for the real maximum. */ min = old_size; max = MAX_SENDBUF_SIZE; while (min <= max) { avg = ((unsigned int)(min + max)) / 2; if (setsockopt(sfd, SOL_SOCKET, SO_SNDBUF, (void *)&avg, intsize) == 0) { last_good = avg; min = avg + 1; } else { max = avg - 1; } } if (settings.verbose > 1) fprintf(stderr, "<%d send buffer was %d, now %d\n", sfd, old_size, last_good); } /** * Create a socket and bind it to a specific port number * @param interface the interface to bind to * @param port the port number to bind to * @param transport the transport protocol (TCP / UDP) * @param portnumber_file A filepointer to write the port numbers to * when they are successfully added to the list of ports we * listen on. */ static int server_socket(const char *interface, int port, enum network_transport transport, FILE *portnumber_file, bool ssl_enabled, uint64_t conntag, enum protocol bproto) { int sfd; struct linger ling = {0, 0}; struct addrinfo *ai; struct addrinfo *next; struct addrinfo hints = { .ai_flags = AI_PASSIVE, .ai_family = AF_UNSPEC }; char port_buf[NI_MAXSERV]; int error; int success = 0; int flags =1; hints.ai_socktype = IS_UDP(transport) ? SOCK_DGRAM : SOCK_STREAM; if (port == -1) { port = 0; } snprintf(port_buf, sizeof(port_buf), "%d", port); error= getaddrinfo(interface, port_buf, &hints, &ai); if (error != 0) { if (error != EAI_SYSTEM) fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(error)); else perror("getaddrinfo()"); return 1; } for (next= ai; next; next= next->ai_next) { conn *listen_conn_add; if ((sfd = new_socket(next)) == -1) { /* getaddrinfo can return "junk" addresses, * we make sure at least one works before erroring. */ if (errno == EMFILE) { /* ...unless we're out of fds */ perror("server_socket"); exit(EX_OSERR); } continue; } if (settings.num_napi_ids) { socklen_t len = sizeof(socklen_t); int napi_id; error = getsockopt(sfd, SOL_SOCKET, SO_INCOMING_NAPI_ID, &napi_id, &len); if (error != 0) { fprintf(stderr, "-N option not supported\n"); exit(EXIT_FAILURE); } } #ifdef IPV6_V6ONLY if (next->ai_family == AF_INET6) { error = setsockopt(sfd, IPPROTO_IPV6, IPV6_V6ONLY, (char *) &flags, sizeof(flags)); if (error != 0) { perror("setsockopt"); close(sfd); continue; } } #endif #ifdef SOCK_COOKIE_ID if (settings.sock_cookie_id != 0) { error = setsockopt(sfd, SOL_SOCKET, SOCK_COOKIE_ID, (void *)&settings.sock_cookie_id, sizeof(uint32_t)); if (error != 0) perror("setsockopt"); } #endif setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags)); if (IS_UDP(transport)) { maximize_sndbuf(sfd); } else { error = setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags)); if (error != 0) perror("setsockopt"); error = setsockopt(sfd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling)); if (error != 0) perror("setsockopt"); error = setsockopt(sfd, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags)); if (error != 0) perror("setsockopt"); } if (bind(sfd, next->ai_addr, next->ai_addrlen) == -1) { if (errno != EADDRINUSE) { perror("bind()"); close(sfd); freeaddrinfo(ai); return 1; } close(sfd); continue; } else { success++; if (!IS_UDP(transport) && listen(sfd, settings.backlog) == -1) { perror("listen()"); close(sfd); freeaddrinfo(ai); return 1; } if (portnumber_file != NULL && (next->ai_addr->sa_family == AF_INET || next->ai_addr->sa_family == AF_INET6)) { union { struct sockaddr_in in; struct sockaddr_in6 in6; } my_sockaddr; socklen_t len = sizeof(my_sockaddr); if (getsockname(sfd, (struct sockaddr*)&my_sockaddr, &len)==0) { if (next->ai_addr->sa_family == AF_INET) { fprintf(portnumber_file, "%s INET: %u\n", IS_UDP(transport) ? "UDP" : "TCP", ntohs(my_sockaddr.in.sin_port)); } else { fprintf(portnumber_file, "%s INET6: %u\n", IS_UDP(transport) ? "UDP" : "TCP", ntohs(my_sockaddr.in6.sin6_port)); } } } } if (IS_UDP(transport)) { int c; for (c = 0; c < settings.num_threads_per_udp; c++) { /* Allocate one UDP file descriptor per worker thread; * this allows "stats conns" to separately list multiple * parallel UDP requests in progress. * * The dispatch code round-robins new connection requests * among threads, so this is guaranteed to assign one * FD to each thread. */ int per_thread_fd; if (c == 0) { per_thread_fd = sfd; } else { per_thread_fd = dup(sfd); if (per_thread_fd < 0) { perror("Failed to duplicate file descriptor"); exit(EXIT_FAILURE); } } dispatch_conn_new(per_thread_fd, conn_read, EV_READ | EV_PERSIST, UDP_READ_BUFFER_SIZE, transport, NULL, conntag, bproto); } } else { if (!(listen_conn_add = conn_new(sfd, conn_listening, EV_READ | EV_PERSIST, 1, transport, main_base, NULL, conntag, bproto))) { fprintf(stderr, "failed to create listening connection\n"); exit(EXIT_FAILURE); } #ifdef TLS listen_conn_add->ssl_enabled = ssl_enabled; #else assert(ssl_enabled == false); #endif listen_conn_add->next = listen_conn; listen_conn = listen_conn_add; } } freeaddrinfo(ai); /* Return zero iff we detected no errors in starting up connections */ return success == 0; } static int server_sockets(int port, enum network_transport transport, FILE *portnumber_file) { bool ssl_enabled = false; #ifdef TLS const char *notls = "notls"; ssl_enabled = settings.ssl_enabled; #endif if (settings.inter == NULL) { return server_socket(settings.inter, port, transport, portnumber_file, ssl_enabled, 0, settings.binding_protocol); } else { // tokenize them and bind to each one of them.. char *b; int ret = 0; char *list = strdup(settings.inter); if (list == NULL) { fprintf(stderr, "Failed to allocate memory for parsing server interface string\n"); return 1; } // If we encounter any failure, preserve the first errno for the caller. int errno_save = 0; for (char *p = strtok_r(list, ";,", &b); p != NULL; p = strtok_r(NULL, ";,", &b)) { uint64_t conntag = 0; int the_port = port; #ifdef TLS ssl_enabled = settings.ssl_enabled; // "notls" option is valid only when memcached is run with SSL enabled. if (strncmp(p, notls, strlen(notls)) == 0) { if (!settings.ssl_enabled) { fprintf(stderr, "'notls' option is valid only when SSL is enabled\n"); free(list); return 1; } ssl_enabled = false; p += strlen(notls) + 1; } #endif // Allow forcing the protocol of this listener. const char *protostr = "proto"; enum protocol bproto = settings.binding_protocol; if (strncmp(p, protostr, strlen(protostr)) == 0) { p += strlen(protostr); if (*p == '[') { char *e = strchr(p, ']'); if (e == NULL) { fprintf(stderr, "Invalid protocol spec: \"%s\"\n", p); free(list); return 1; } char *st = ++p; // skip '['; *e = '\0'; size_t len = e - st; p = ++e; // skip ']' p++; // skip an assumed ':' if (strncmp(st, "ascii", len) == 0) { bproto = ascii_prot; } else if (strncmp(st, "binary", len) == 0) { bproto = binary_prot; } else if (strncmp(st, "negotiating", len) == 0) { bproto = negotiating_prot; } else if (strncmp(st, "proxy", len) == 0) { #ifdef PROXY if (settings.proxy_enabled) { bproto = proxy_prot; } else { fprintf(stderr, "Proxy must be enabled to use: \"%s\"\n", list); free(list); return 1; } #else fprintf(stderr, "Server not built with proxy: \"%s\"\n", list); free(list); return 1; #endif } } } const char *tagstr = "tag"; if (strncmp(p, tagstr, strlen(tagstr)) == 0) { p += strlen(tagstr); if (*p == '[') { char *e = strchr(p, ']'); if (e == NULL) { fprintf(stderr, "Invalid tag in socket config: \"%s\"\n", p); free(list); return 1; } char *st = ++p; // skip '[' *e = '\0'; size_t len = e - st; p = ++e; // skip ']' p++; // skip an assumed ':' // validate the tag and copy it in. if (len > 8 || len < 1) { fprintf(stderr, "Listener tags must be between 1 and 8 characters: \"%s\"\n", st); free(list); return 1; } // C programmers love turning string comparisons into // integer comparisons. memcpy(&conntag, st, len); } } char *h = NULL; if (*p == '[') { // expecting it to be an IPv6 address enclosed in [] // i.e. RFC3986 style recommended by RFC5952 char *e = strchr(p, ']'); if (e == NULL) { fprintf(stderr, "Invalid IPV6 address: \"%s\"", p); free(list); return 1; } h = ++p; // skip the opening '[' *e = '\0'; p = ++e; // skip the closing ']' } char *s = strchr(p, ':'); if (s != NULL) { // If no more semicolons - attempt to treat as port number. // Otherwise the only valid option is an unenclosed IPv6 without port, until // of course there was an RFC3986 IPv6 address previously specified - // in such a case there is no good option, will just send it to fail as port number. if (strchr(s + 1, ':') == NULL || h != NULL) { *s = '\0'; ++s; if (!safe_strtol(s, &the_port)) { fprintf(stderr, "Invalid port number: \"%s\"\n", s); free(list); return 1; } } } if (h != NULL) p = h; if (strcmp(p, "*") == 0) { p = NULL; } ret |= server_socket(p, the_port, transport, portnumber_file, ssl_enabled, conntag, bproto); if (ret != 0 && errno_save == 0) errno_save = errno; } free(list); errno = errno_save; return ret; } } #ifndef DISABLE_UNIX_SOCKET static int new_socket_unix(void) { int sfd; int flags; if ((sfd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { perror("socket()"); return -1; } if ((flags = fcntl(sfd, F_GETFL, 0)) < 0 || fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) { perror("setting O_NONBLOCK"); close(sfd); return -1; } return sfd; } static int server_socket_unix(const char *path, int access_mask) { int sfd; struct linger ling = {0, 0}; struct sockaddr_un addr; struct stat tstat; int flags =1; int old_umask; if (!path) { return 1; } if ((sfd = new_socket_unix()) == -1) { return 1; } /* * Clean up a previous socket file if we left it around */ if (lstat(path, &tstat) == 0) { if (S_ISSOCK(tstat.st_mode)) unlink(path); } setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags)); setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags)); setsockopt(sfd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling)); /* * the memset call clears nonstandard fields in some implementations * that otherwise mess things up. */ memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1); assert(strcmp(addr.sun_path, path) == 0); old_umask = umask( ~(access_mask&0777)); if (bind(sfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) { perror("bind()"); close(sfd); umask(old_umask); return 1; } umask(old_umask); if (listen(sfd, settings.backlog) == -1) { perror("listen()"); close(sfd); return 1; } if (!(listen_conn = conn_new(sfd, conn_listening, EV_READ | EV_PERSIST, 1, local_transport, main_base, NULL, 0, settings.binding_protocol))) { fprintf(stderr, "failed to create listening connection\n"); exit(EXIT_FAILURE); } return 0; } #else #define server_socket_unix(path, access_mask) -1 #endif /* #ifndef DISABLE_UNIX_SOCKET */ /* * We keep the current time of day in a global variable that's updated by a * timer event. This saves us a bunch of time() system calls (we really only * need to get the time once a second, whereas there can be tens of thousands * of requests a second) and allows us to use server-start-relative timestamps * rather than absolute UNIX timestamps, a space savings on systems where * sizeof(time_t) > sizeof(unsigned int). */ volatile rel_time_t current_time; static struct event clockevent; #ifdef MEMCACHED_DEBUG volatile bool is_paused; volatile int64_t delta; #endif #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) static bool monotonic = false; static int64_t monotonic_start; #endif /* libevent uses a monotonic clock when available for event scheduling. Aside * from jitter, simply ticking our internal timer here is accurate enough. * Note that users who are setting explicit dates for expiration times *must* * ensure their clocks are correct before starting memcached. */ static void clock_handler(const evutil_socket_t fd, const short which, void *arg) { struct timeval t = {.tv_sec = 1, .tv_usec = 0}; static bool initialized = false; if (initialized) { /* only delete the event if it's actually there. */ evtimer_del(&clockevent); } else { initialized = true; } // While we're here, check for hash table expansion. // This function should be quick to avoid delaying the timer. assoc_start_expand(stats_state.curr_items); // also, if HUP'ed we need to do some maintenance. // for now that's just the authfile reload. if (settings.sig_hup) { settings.sig_hup = false; authfile_load(settings.auth_file); #ifdef PROXY if (settings.proxy_ctx) { proxy_start_reload(settings.proxy_ctx); } #endif } evtimer_set(&clockevent, clock_handler, 0); event_base_set(main_base, &clockevent); evtimer_add(&clockevent, &t); #ifdef MEMCACHED_DEBUG if (is_paused) return; #endif #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) if (monotonic) { struct timespec ts; if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) return; #ifdef MEMCACHED_DEBUG current_time = (rel_time_t) (ts.tv_sec - monotonic_start + delta); #else current_time = (rel_time_t) (ts.tv_sec - monotonic_start); #endif return; } #endif { struct timeval tv; gettimeofday(&tv, NULL); #ifdef MEMCACHED_DEBUG current_time = (rel_time_t) (tv.tv_sec - process_started + delta); #else current_time = (rel_time_t) (tv.tv_sec - process_started); #endif } } static const char* flag_enabled_disabled(bool flag) { return (flag ? "enabled" : "disabled"); } static void verify_default(const char* param, bool condition) { if (!condition) { printf("Default value of [%s] has changed." " Modify the help text and default value check.\n", param); exit(EXIT_FAILURE); } } static void usage(void) { printf(PACKAGE " " VERSION "\n"); printf("-p, --port= TCP port to listen on (default: %d)\n" "-U, --udp-port= UDP port to listen on (default: %d, off)\n", settings.port, settings.udpport); #ifndef DISABLE_UNIX_SOCKET printf("-s, --unix-socket= UNIX socket to listen on (disables network support)\n"); printf("-a, --unix-mask= access mask for UNIX socket, in octal (default: %o)\n", settings.access); #endif /* #ifndef DISABLE_UNIX_SOCKET */ printf("-A, --enable-shutdown enable ascii \"shutdown\" command\n"); printf("-l, --listen= interface to listen on (default: INADDR_ANY)\n"); #ifdef TLS printf(" if TLS/SSL is enabled, 'notls' prefix can be used to\n" " disable for specific listeners (-l notls::) \n"); #endif printf("-d, --daemon run as a daemon\n" "-r, --enable-coredumps maximize core file limit\n" "-u, --user= assume identity of (only when run as root)\n" "-m, --memory-limit= item memory in megabytes (default: %lu)\n" "-M, --disable-evictions return error on memory exhausted instead of evicting\n" "-c, --conn-limit= max simultaneous connections (default: %d)\n" "-k, --lock-memory lock down all paged memory\n" "-v, --verbose verbose (print errors/warnings while in event loop)\n" "-vv very verbose (also print client commands/responses)\n" "-vvv extremely verbose (internal state transitions)\n" "-h, --help print this help and exit\n" "-i, --license print memcached and libevent license\n" "-V, --version print version and exit\n" "-P, --pidfile= save PID in , only used with -d option\n" "-f, --slab-growth-factor= chunk size growth factor (default: %2.2f)\n" "-n, --slab-min-size= min space used for key+value+flags (default: %d)\n", (unsigned long) settings.maxbytes / (1 << 20), settings.maxconns, settings.factor, settings.chunk_size); verify_default("udp-port",settings.udpport == 0); printf("-L, --enable-largepages try to use large memory pages (if available)\n"); printf("-D Use as the delimiter between key prefixes and IDs.\n" " This is used for per-prefix stats reporting. The default is\n" " \"%c\" (colon). If this option is specified, stats collection\n" " is turned on automatically; if not, then it may be turned on\n" " by sending the \"stats detail on\" command to the server.\n", settings.prefix_delimiter); printf("-t, --threads= number of threads to use (default: %d)\n", settings.num_threads); printf("-R, --max-reqs-per-event maximum number of requests per event, limits the\n" " requests processed per connection to prevent \n" " starvation (default: %d)\n", settings.reqs_per_event); printf("-C, --disable-cas disable use of CAS\n"); printf("-b, --listen-backlog= set the backlog queue limit (default: %d)\n", settings.backlog); printf("-B, --protocol= protocol - one of ascii, binary, or auto (default: %s)\n", prot_text(settings.binding_protocol)); printf("-I, --max-item-size= adjusts max item size\n" " (default: %dm, min: %dk, max: %dm)\n", settings.item_size_max/ (1 << 20), ITEM_SIZE_MAX_LOWER_LIMIT / (1 << 10), ITEM_SIZE_MAX_UPPER_LIMIT / (1 << 20)); #ifdef ENABLE_SASL printf("-S, --enable-sasl turn on Sasl authentication\n"); #endif printf("-F, --disable-flush-all disable flush_all command\n"); printf("-X, --disable-dumping disable stats cachedump and lru_crawler metadump\n"); printf("-W --disable-watch disable watch commands (live logging)\n"); printf("-Y, --auth-file= (EXPERIMENTAL) enable ASCII protocol authentication. format:\n" " user:pass\\nuser2:pass2\\n\n"); printf("-e, --memory-file= (EXPERIMENTAL) mmap a file for item memory.\n" " use only in ram disks or persistent memory mounts!\n" " enables restartable cache (stop with SIGUSR1)\n"); #ifdef TLS printf("-Z, --enable-ssl enable TLS/SSL\n"); #endif printf("-o, --extended comma separated list of extended options\n" " most options have a 'no_' prefix to disable\n" " - maxconns_fast: immediately close new connections after limit (default: %s)\n" " - hashpower: an integer multiplier for how large the hash\n" " table should be. normally grows at runtime. (default starts at: %d)\n" " set based on \"STAT hash_power_level\"\n" " - tail_repair_time: time in seconds for how long to wait before\n" " forcefully killing LRU tail item.\n" " disabled by default; very dangerous option.\n" " - hash_algorithm: the hash table algorithm\n" " default is murmur3 hash. options: jenkins, murmur3, xxh3\n" " - no_lru_crawler: disable LRU Crawler background thread.\n" " - lru_crawler_sleep: microseconds to sleep between items\n" " default is %d.\n" " - lru_crawler_tocrawl: max items to crawl per slab per run\n" " default is %u (unlimited)\n", flag_enabled_disabled(settings.maxconns_fast), settings.hashpower_init, settings.lru_crawler_sleep, settings.lru_crawler_tocrawl); printf(" - read_buf_mem_limit: limit in megabytes for connection read/response buffers.\n" " do not adjust unless you have high (20k+) conn. limits.\n" " 0 means unlimited (default: %u)\n", settings.read_buf_mem_limit); verify_default("read_buf_mem_limit", settings.read_buf_mem_limit == 0); printf(" - no_lru_maintainer: disable new LRU system + background thread.\n" " - hot_lru_pct: pct of slab memory to reserve for hot lru.\n" " (requires lru_maintainer, default pct: %d)\n" " - warm_lru_pct: pct of slab memory to reserve for warm lru.\n" " (requires lru_maintainer, default pct: %d)\n" " - hot_max_factor: items idle > cold lru age * drop from hot lru. (default: %.2f)\n" " - warm_max_factor: items idle > cold lru age * this drop from warm. (default: %.2f)\n" " - temporary_ttl: TTL's below get separate LRU, can't be evicted.\n" " (requires lru_maintainer, default: %d)\n" " - idle_timeout: timeout for idle connections. (default: %d, no timeout)\n", settings.hot_lru_pct, settings.warm_lru_pct, settings.hot_max_factor, settings.warm_max_factor, settings.temporary_ttl, settings.idle_timeout); printf(" - slab_chunk_max: (EXPERIMENTAL) maximum slab size in kilobytes. use extreme care. (default: %d)\n" " - watcher_logbuf_size: size in kilobytes of per-watcher write buffer. (default: %u)\n" " - worker_logbuf_size: size in kilobytes of per-worker-thread buffer\n" " read by background thread, then written to watchers. (default: %u)\n" " - track_sizes: enable dynamic reports for 'stats sizes' command.\n" " - no_hashexpand: disables hash table expansion (dangerous)\n" " - modern: enables options which will be default in future.\n" " currently: nothing\n" " - no_modern: uses defaults of previous major version (1.4.x)\n", settings.slab_chunk_size_max / (1 << 10), settings.logger_watcher_buf_size / (1 << 10), settings.logger_buf_size / (1 << 10)); verify_default("tail_repair_time", settings.tail_repair_time == TAIL_REPAIR_TIME_DEFAULT); verify_default("lru_crawler_tocrawl", settings.lru_crawler_tocrawl == 0); verify_default("idle_timeout", settings.idle_timeout == 0); #ifdef HAVE_DROP_PRIVILEGES printf(" - drop_privileges: enable dropping extra syscall privileges\n" " - no_drop_privileges: disable drop_privileges in case it causes issues with\n" " some customisation.\n" " (default is no_drop_privileges)\n"); verify_default("drop_privileges", !settings.drop_privileges); #ifdef MEMCACHED_DEBUG printf(" - relaxed_privileges: running tests requires extra privileges. (default: %s)\n", flag_enabled_disabled(settings.relaxed_privileges)); #endif #endif #ifdef SOCK_COOKIE_ID printf(" - sock_cookie_id: attributes an ID to a socket for ip filtering/firewalls \n"); #endif #ifdef EXTSTORE printf("\n - External storage (ext_*) related options (see: https://memcached.org/extstore)\n"); printf(" - ext_path: file to write to for external storage.\n" " ie: ext_path=/mnt/d1/extstore:1G\n" " - ext_page_size: size in megabytes of storage pages. (default: %u)\n" " - ext_wbuf_size: size in megabytes of page write buffers. (default: %u)\n" " - ext_threads: number of IO threads to run. (default: %u)\n" " - ext_item_size: store items larger than this (bytes, default %u)\n" " - ext_item_age: store items idle at least this long (seconds, default: no age limit)\n" " - ext_low_ttl: consider TTLs lower than this specially (default: %u)\n" " - ext_drop_unread: don't re-write unread values during compaction (default: %s)\n" " - ext_recache_rate: recache an item every N accesses (default: %u)\n" " - ext_compact_under: compact when fewer than this many free pages\n" " (default: 1/4th of the assigned storage)\n" " - ext_drop_under: drop COLD items when fewer than this many free pages\n" " (default: 1/4th of the assigned storage)\n" " - ext_max_frag: max page fragmentation to tolerate (default: %.2f)\n" " - ext_max_sleep: max sleep time of background threads in us (default: %u)\n" " - slab_automove_freeratio: ratio of memory to hold free as buffer.\n" " (see doc/storage.txt for more info, default: %.3f)\n", settings.ext_page_size / (1 << 20), settings.ext_wbuf_size / (1 << 20), settings.ext_io_threadcount, settings.ext_item_size, settings.ext_low_ttl, flag_enabled_disabled(settings.ext_drop_unread), settings.ext_recache_rate, settings.ext_max_frag, settings.ext_max_sleep, settings.slab_automove_freeratio); verify_default("ext_item_age", settings.ext_item_age == UINT_MAX); #endif #ifdef PROXY printf(" - proxy_config: path to lua config file.\n"); #endif #ifdef TLS printf(" - ssl_chain_cert: certificate chain file in PEM format\n" " - ssl_key: private key, if not part of the -ssl_chain_cert\n" " - ssl_keyformat: private key format (PEM, DER or ENGINE) (default: PEM)\n"); printf(" - ssl_verify_mode: peer certificate verification mode, default is 0(None).\n" " valid values are 0(None), 1(Request), 2(Require)\n" " or 3(Once)\n"); printf(" - ssl_ciphers: specify cipher list to be used\n" " - ssl_ca_cert: PEM format file of acceptable client CA's\n" " - ssl_wbuf_size: size in kilobytes of per-connection SSL output buffer\n" " (default: %u)\n", settings.ssl_wbuf_size / (1 << 10)); printf(" - ssl_session_cache: enable server-side SSL session cache, to support session\n" " resumption\n" " - ssl_kernel_tls: enable kernel TLS offload\n" " - ssl_min_version: minimum protocol version to accept (default: %s)\n", ssl_proto_text(settings.ssl_min_version)); #if defined(TLS1_3_VERSION) printf(" valid values are 0(%s), 1(%s), 2(%s), or 3(%s).\n", ssl_proto_text(TLS1_VERSION), ssl_proto_text(TLS1_1_VERSION), ssl_proto_text(TLS1_2_VERSION), ssl_proto_text(TLS1_3_VERSION)); #else printf(" valid values are 0(%s), 1(%s), or 2(%s).\n", ssl_proto_text(TLS1_VERSION), ssl_proto_text(TLS1_1_VERSION), ssl_proto_text(TLS1_2_VERSION)); #endif verify_default("ssl_keyformat", settings.ssl_keyformat == SSL_FILETYPE_PEM); verify_default("ssl_verify_mode", settings.ssl_verify_mode == SSL_VERIFY_NONE); verify_default("ssl_min_version", settings.ssl_min_version == TLS1_2_VERSION); #endif printf("-N, --napi_ids number of napi ids. see doc/napi_ids.txt for more details\n"); return; } static void usage_license(void) { printf(PACKAGE " " VERSION "\n\n"); printf( "Copyright (c) 2003, Danga Interactive, Inc. \n" "All rights reserved.\n" "\n" "Redistribution and use in source and binary forms, with or without\n" "modification, are permitted provided that the following conditions are\n" "met:\n" "\n" " * Redistributions of source code must retain the above copyright\n" "notice, this list of conditions and the following disclaimer.\n" "\n" " * Redistributions in binary form must reproduce the above\n" "copyright notice, this list of conditions and the following disclaimer\n" "in the documentation and/or other materials provided with the\n" "distribution.\n" "\n" " * Neither the name of the Danga Interactive nor the names of its\n" "contributors may be used to endorse or promote products derived from\n" "this software without specific prior written permission.\n" "\n" "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n" "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n" "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n" "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n" "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n" "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n" "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n" "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n" "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n" "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n" "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" ); return; } static void save_pid(const char *pid_file) { FILE *fp; if (access(pid_file, F_OK) == 0) { if ((fp = fopen(pid_file, "r")) != NULL) { char buffer[1024]; if (fgets(buffer, sizeof(buffer), fp) != NULL) { unsigned int pid; if (safe_strtoul(buffer, &pid) && kill((pid_t)pid, 0) == 0) { fprintf(stderr, "WARNING: The pid file contained the following (running) pid: %u\n", pid); } } fclose(fp); } } /* Create the pid file first with a temporary name, then * atomically move the file to the real name to avoid a race with * another process opening the file to read the pid, but finding * it empty. */ char tmp_pid_file[1024]; snprintf(tmp_pid_file, sizeof(tmp_pid_file), "%s.tmp", pid_file); if ((fp = fopen(tmp_pid_file, "w")) == NULL) { vperror("Could not open the pid file %s for writing", tmp_pid_file); return; } fprintf(fp,"%ld\n", (long)getpid()); if (fclose(fp) == -1) { vperror("Could not close the pid file %s", tmp_pid_file); } if (rename(tmp_pid_file, pid_file) != 0) { vperror("Could not rename the pid file from %s to %s", tmp_pid_file, pid_file); } } static void remove_pidfile(const char *pid_file) { if (pid_file == NULL) return; if (unlink(pid_file) != 0) { vperror("Could not remove the pid file %s", pid_file); } } static void sig_handler(const int sig) { stop_main_loop = EXIT_NORMALLY; } static void sighup_handler(const int sig) { settings.sig_hup = true; } static void sig_usrhandler(const int sig) { stop_main_loop = GRACE_STOP; } /* * On systems that supports multiple page sizes we may reduce the * number of TLB-misses by using the biggest available page size */ static int enable_large_pages(void) { #if defined(HAVE_GETPAGESIZES) && defined(HAVE_MEMCNTL) int ret = -1; size_t sizes[32]; int avail = getpagesizes(sizes, 32); if (avail != -1) { size_t max = sizes[0]; struct memcntl_mha arg = {0}; int ii; for (ii = 1; ii < avail; ++ii) { if (max < sizes[ii]) { max = sizes[ii]; } } arg.mha_flags = 0; arg.mha_pagesize = max; arg.mha_cmd = MHA_MAPSIZE_BSSBRK; if (memcntl(0, 0, MC_HAT_ADVISE, (caddr_t)&arg, 0, 0) == -1) { fprintf(stderr, "Failed to set large pages: %s\n", strerror(errno)); fprintf(stderr, "Will use default page size\n"); } else { ret = 0; } } else { fprintf(stderr, "Failed to get supported pagesizes: %s\n", strerror(errno)); fprintf(stderr, "Will use default page size\n"); } return ret; #elif defined(__linux__) && defined(MADV_HUGEPAGE) /* check if transparent hugepages is compiled into the kernel */ /* RH based systems possibly uses a different path */ static const char *mm_thp_paths[] = { "/sys/kernel/mm/transparent_hugepage/enabled", "/sys/kernel/mm/redhat_transparent_hugepage/enabled", NULL }; char thpb[128] = {0}; int pfd = -1; for (const char **p = mm_thp_paths; *p; p++) { if ((pfd = open(*p, O_RDONLY)) != -1) break; } if (pfd == -1) { fprintf(stderr, "Transparent huge pages support not detected.\n"); fprintf(stderr, "Will use default page size.\n"); return -1; } ssize_t rd = read(pfd, thpb, sizeof(thpb)); close(pfd); if (rd <= 0) { fprintf(stderr, "Transparent huge pages could not read the configuration.\n"); fprintf(stderr, "Will use default page size.\n"); return -1; } thpb[rd] = 0; if (strstr(thpb, "[never]")) { fprintf(stderr, "Transparent huge pages support disabled.\n"); fprintf(stderr, "Will use default page size.\n"); return -1; } return 0; #elif defined(__FreeBSD__) int spages; size_t spagesl = sizeof(spages); if (sysctlbyname("vm.pmap.pg_ps_enabled", &spages, &spagesl, NULL, 0) != 0) { fprintf(stderr, "Could not evaluate the presence of superpages features."); return -1; } if (spages != 1) { fprintf(stderr, "Superpages support not detected.\n"); fprintf(stderr, "Will use default page size.\n"); return -1; } return 0; #else return -1; #endif } /** * Do basic sanity check of the runtime environment * @return true if no errors found, false if we can't use this env */ static bool sanitycheck(void) { /* One of our biggest problems is old and bogus libevents */ const char *ever = event_get_version(); if (ever != NULL) { if (strncmp(ever, "1.", 2) == 0) { fprintf(stderr, "You are using libevent %s.\nPlease upgrade to 2.x" " or newer\n", event_get_version()); return false; } } return true; } static bool _parse_slab_sizes(char *s, uint32_t *slab_sizes) { char *b = NULL; uint32_t size = 0; int i = 0; uint32_t last_size = 0; if (strlen(s) < 1) return false; for (char *p = strtok_r(s, "-", &b); p != NULL; p = strtok_r(NULL, "-", &b)) { if (!safe_strtoul(p, &size) || size < settings.chunk_size || size > settings.slab_chunk_size_max) { fprintf(stderr, "slab size %u is out of valid range\n", size); return false; } if (last_size >= size) { fprintf(stderr, "slab size %u cannot be lower than or equal to a previous class size\n", size); return false; } if (size <= last_size + CHUNK_ALIGN_BYTES) { fprintf(stderr, "slab size %u must be at least %d bytes larger than previous class\n", size, CHUNK_ALIGN_BYTES); return false; } slab_sizes[i++] = size; last_size = size; if (i >= MAX_NUMBER_OF_SLAB_CLASSES-1) { fprintf(stderr, "too many slab classes specified\n"); return false; } } slab_sizes[i] = 0; return true; } struct _mc_meta_data { void *mmap_base; uint64_t old_base; char *slab_config; // string containing either factor or custom slab list. int64_t time_delta; uint64_t process_started; uint32_t current_time; }; // We need to remember a combination of configuration settings and global // state for restart viability and resumption of internal services. // Compared to the number of tunables and state values, relatively little // does need to be remembered. // Time is the hardest; we have to assume the sys clock is correct and re-sync for // the lost time after restart. static int _mc_meta_save_cb(const char *tag, void *ctx, void *data) { struct _mc_meta_data *meta = (struct _mc_meta_data *)data; // Settings to remember. // TODO: should get a version of version which is numeric, else // comparisons for compat reasons are difficult. // it may be possible to punt on this for now; since we can test for the // absence of another key... such as the new numeric version. //restart_set_kv(ctx, "version", "%s", VERSION); // We hold the original factor or subopts _string_ // it can be directly compared without roundtripping through floats or // serializing/deserializing the long options list. restart_set_kv(ctx, "slab_config", "%s", meta->slab_config); restart_set_kv(ctx, "maxbytes", "%llu", (unsigned long long) settings.maxbytes); restart_set_kv(ctx, "chunk_size", "%d", settings.chunk_size); restart_set_kv(ctx, "item_size_max", "%d", settings.item_size_max); restart_set_kv(ctx, "slab_chunk_size_max", "%d", settings.slab_chunk_size_max); restart_set_kv(ctx, "slab_page_size", "%d", settings.slab_page_size); restart_set_kv(ctx, "use_cas", "%s", settings.use_cas ? "true" : "false"); restart_set_kv(ctx, "slab_reassign", "%s", settings.slab_reassign ? "true" : "false"); // Online state to remember. // current time is tough. we need to rely on the clock being correct to // pull the delta between stop and start times. we also need to know the // delta between start time and now to restore monotonic clocks. // for non-monotonic clocks (some OS?), process_started is the only // important one. restart_set_kv(ctx, "current_time", "%u", current_time); // types are great until... this. some systems time_t could be big, but // I'm assuming never negative. restart_set_kv(ctx, "process_started", "%llu", (unsigned long long) process_started); { struct timeval tv; gettimeofday(&tv, NULL); restart_set_kv(ctx, "stop_time", "%lu", tv.tv_sec); } // Might as well just fetch the next CAS value to use than tightly // coupling the internal variable into the restart system. restart_set_kv(ctx, "current_cas", "%llu", (unsigned long long) get_cas_id()); restart_set_kv(ctx, "oldest_cas", "%llu", (unsigned long long) settings.oldest_cas); restart_set_kv(ctx, "logger_gid", "%llu", logger_get_gid()); restart_set_kv(ctx, "hashpower", "%u", stats_state.hash_power_level); // NOTE: oldest_live is a rel_time_t, which aliases for unsigned int. // should future proof this with a 64bit upcast, or fetch value from a // converter function/macro? restart_set_kv(ctx, "oldest_live", "%u", settings.oldest_live); // TODO: use uintptr_t etc? is it portable enough? restart_set_kv(ctx, "mmap_oldbase", "%p", meta->mmap_base); return 0; } // We must see at least this number of checked lines. Else empty/missing lines // could cause a false-positive. // TODO: Once crc32'ing of the metadata file is done this could be ensured better by // the restart module itself (crc32 + count of lines must match on the // backend) #define RESTART_REQUIRED_META 17 // With this callback we make a decision on if the current configuration // matches up enough to allow reusing the cache. // We also re-load important runtime information. static int _mc_meta_load_cb(const char *tag, void *ctx, void *data) { struct _mc_meta_data *meta = (struct _mc_meta_data *)data; char *key; char *val; int reuse_mmap = 0; meta->process_started = 0; meta->time_delta = 0; meta->current_time = 0; int lines_seen = 0; // TODO: not sure this is any better than just doing an if/else tree with // strcmp's... enum { R_MMAP_OLDBASE = 0, R_MAXBYTES, R_CHUNK_SIZE, R_ITEM_SIZE_MAX, R_SLAB_CHUNK_SIZE_MAX, R_SLAB_PAGE_SIZE, R_SLAB_CONFIG, R_USE_CAS, R_SLAB_REASSIGN, R_CURRENT_CAS, R_OLDEST_CAS, R_OLDEST_LIVE, R_LOGGER_GID, R_CURRENT_TIME, R_STOP_TIME, R_PROCESS_STARTED, R_HASHPOWER, }; const char *opts[] = { [R_MMAP_OLDBASE] = "mmap_oldbase", [R_MAXBYTES] = "maxbytes", [R_CHUNK_SIZE] = "chunk_size", [R_ITEM_SIZE_MAX] = "item_size_max", [R_SLAB_CHUNK_SIZE_MAX] = "slab_chunk_size_max", [R_SLAB_PAGE_SIZE] = "slab_page_size", [R_SLAB_CONFIG] = "slab_config", [R_USE_CAS] = "use_cas", [R_SLAB_REASSIGN] = "slab_reassign", [R_CURRENT_CAS] = "current_cas", [R_OLDEST_CAS] = "oldest_cas", [R_OLDEST_LIVE] = "oldest_live", [R_LOGGER_GID] = "logger_gid", [R_CURRENT_TIME] = "current_time", [R_STOP_TIME] = "stop_time", [R_PROCESS_STARTED] = "process_started", [R_HASHPOWER] = "hashpower", NULL }; while (restart_get_kv(ctx, &key, &val) == RESTART_OK) { int type = 0; int32_t val_int = 0; uint32_t val_uint = 0; int64_t bigval_int = 0; uint64_t bigval_uint = 0; while (opts[type] != NULL && strcmp(key, opts[type]) != 0) { type++; } if (opts[type] == NULL) { fprintf(stderr, "[restart] unknown/unhandled key: %s\n", key); continue; } lines_seen++; // helper for any boolean checkers. bool val_bool = false; bool is_bool = true; if (strcmp(val, "false") == 0) { val_bool = false; } else if (strcmp(val, "true") == 0) { val_bool = true; } else { is_bool = false; } switch (type) { case R_MMAP_OLDBASE: if (!safe_strtoull_hex(val, &meta->old_base)) { fprintf(stderr, "[restart] failed to parse %s: %s\n", key, val); reuse_mmap = -1; } break; case R_MAXBYTES: if (!safe_strtoll(val, &bigval_int) || settings.maxbytes != bigval_int) { reuse_mmap = -1; } break; case R_CHUNK_SIZE: if (!safe_strtol(val, &val_int) || settings.chunk_size != val_int) { reuse_mmap = -1; } break; case R_ITEM_SIZE_MAX: if (!safe_strtol(val, &val_int) || settings.item_size_max != val_int) { reuse_mmap = -1; } break; case R_SLAB_CHUNK_SIZE_MAX: if (!safe_strtol(val, &val_int) || settings.slab_chunk_size_max != val_int) { reuse_mmap = -1; } break; case R_SLAB_PAGE_SIZE: if (!safe_strtol(val, &val_int) || settings.slab_page_size != val_int) { reuse_mmap = -1; } break; case R_SLAB_CONFIG: if (strcmp(val, meta->slab_config) != 0) { reuse_mmap = -1; } break; case R_USE_CAS: if (!is_bool || settings.use_cas != val_bool) { reuse_mmap = -1; } break; case R_SLAB_REASSIGN: if (!is_bool || settings.slab_reassign != val_bool) { reuse_mmap = -1; } break; case R_CURRENT_CAS: // FIXME: do we need to fail if these values _aren't_ found? if (!safe_strtoull(val, &bigval_uint)) { reuse_mmap = -1; } else { set_cas_id(bigval_uint); } break; case R_OLDEST_CAS: if (!safe_strtoull(val, &bigval_uint)) { reuse_mmap = -1; } else { settings.oldest_cas = bigval_uint; } break; case R_OLDEST_LIVE: if (!safe_strtoul(val, &val_uint)) { reuse_mmap = -1; } else { settings.oldest_live = val_uint; } break; case R_LOGGER_GID: if (!safe_strtoull(val, &bigval_uint)) { reuse_mmap = -1; } else { logger_set_gid(bigval_uint); } break; case R_PROCESS_STARTED: if (!safe_strtoull(val, &bigval_uint)) { reuse_mmap = -1; } else { meta->process_started = bigval_uint; } break; case R_CURRENT_TIME: if (!safe_strtoul(val, &val_uint)) { reuse_mmap = -1; } else { meta->current_time = val_uint; } break; case R_STOP_TIME: if (!safe_strtoll(val, &bigval_int)) { reuse_mmap = -1; } else { struct timeval t; gettimeofday(&t, NULL); meta->time_delta = t.tv_sec - bigval_int; // clock has done something crazy. // there are _lots_ of ways the clock can go wrong here, but // this is a safe sanity check since there's nothing else we // can realistically do. if (meta->time_delta <= 0) { reuse_mmap = -1; } } break; case R_HASHPOWER: if (!safe_strtoul(val, &val_uint)) { reuse_mmap = -1; } else { settings.hashpower_init = val_uint; } break; default: fprintf(stderr, "[restart] unhandled key: %s\n", key); } if (reuse_mmap != 0) { fprintf(stderr, "[restart] restart incompatible due to setting for [%s] [old value: %s]\n", key, val); break; } } if (lines_seen < RESTART_REQUIRED_META) { fprintf(stderr, "[restart] missing some metadata lines\n"); reuse_mmap = -1; } return reuse_mmap; } int main (int argc, char **argv) { int c; bool lock_memory = false; bool do_daemonize = false; bool preallocate = false; int maxcore = 0; char *username = NULL; char *pid_file = NULL; struct passwd *pw; struct rlimit rlim; char *buf; char unit = '\0'; int size_max = 0; int retval = EXIT_SUCCESS; bool protocol_specified = false; bool tcp_specified = false; bool udp_specified = false; bool start_lru_maintainer = true; bool start_lru_crawler = true; bool start_assoc_maint = true; enum hashfunc_type hash_type = MURMUR3_HASH; uint32_t tocrawl; uint32_t slab_sizes[MAX_NUMBER_OF_SLAB_CLASSES]; bool use_slab_sizes = false; char *slab_sizes_unparsed = NULL; bool slab_chunk_size_changed = false; // struct for restart code. Initialized up here so we can curry // important settings to save or validate. struct _mc_meta_data *meta = malloc(sizeof(struct _mc_meta_data)); meta->slab_config = NULL; char *subopts, *subopts_orig; char *subopts_value; enum { MAXCONNS_FAST = 0, HASHPOWER_INIT, NO_HASHEXPAND, SLAB_REASSIGN, SLAB_AUTOMOVE, SLAB_AUTOMOVE_RATIO, SLAB_AUTOMOVE_WINDOW, TAIL_REPAIR_TIME, HASH_ALGORITHM, LRU_CRAWLER, LRU_CRAWLER_SLEEP, LRU_CRAWLER_TOCRAWL, LRU_MAINTAINER, HOT_LRU_PCT, WARM_LRU_PCT, HOT_MAX_FACTOR, WARM_MAX_FACTOR, TEMPORARY_TTL, IDLE_TIMEOUT, WATCHER_LOGBUF_SIZE, WORKER_LOGBUF_SIZE, SLAB_SIZES, SLAB_CHUNK_MAX, TRACK_SIZES, NO_INLINE_ASCII_RESP, MODERN, NO_MODERN, NO_CHUNKED_ITEMS, NO_SLAB_REASSIGN, NO_SLAB_AUTOMOVE, NO_MAXCONNS_FAST, INLINE_ASCII_RESP, NO_LRU_CRAWLER, NO_LRU_MAINTAINER, NO_DROP_PRIVILEGES, DROP_PRIVILEGES, RESP_OBJ_MEM_LIMIT, READ_BUF_MEM_LIMIT, #ifdef TLS SSL_CERT, SSL_KEY, SSL_VERIFY_MODE, SSL_KEYFORM, SSL_CIPHERS, SSL_CA_CERT, SSL_WBUF_SIZE, SSL_SESSION_CACHE, SSL_KERNEL_TLS, SSL_MIN_VERSION, #endif #ifdef PROXY PROXY_CONFIG, PROXY_URING, #endif #ifdef MEMCACHED_DEBUG RELAXED_PRIVILEGES, #endif #ifdef SOCK_COOKIE_ID COOKIE_ID, #endif }; char *const subopts_tokens[] = { [MAXCONNS_FAST] = "maxconns_fast", [HASHPOWER_INIT] = "hashpower", [NO_HASHEXPAND] = "no_hashexpand", [SLAB_REASSIGN] = "slab_reassign", [SLAB_AUTOMOVE] = "slab_automove", [SLAB_AUTOMOVE_RATIO] = "slab_automove_ratio", [SLAB_AUTOMOVE_WINDOW] = "slab_automove_window", [TAIL_REPAIR_TIME] = "tail_repair_time", [HASH_ALGORITHM] = "hash_algorithm", [LRU_CRAWLER] = "lru_crawler", [LRU_CRAWLER_SLEEP] = "lru_crawler_sleep", [LRU_CRAWLER_TOCRAWL] = "lru_crawler_tocrawl", [LRU_MAINTAINER] = "lru_maintainer", [HOT_LRU_PCT] = "hot_lru_pct", [WARM_LRU_PCT] = "warm_lru_pct", [HOT_MAX_FACTOR] = "hot_max_factor", [WARM_MAX_FACTOR] = "warm_max_factor", [TEMPORARY_TTL] = "temporary_ttl", [IDLE_TIMEOUT] = "idle_timeout", [WATCHER_LOGBUF_SIZE] = "watcher_logbuf_size", [WORKER_LOGBUF_SIZE] = "worker_logbuf_size", [SLAB_SIZES] = "slab_sizes", [SLAB_CHUNK_MAX] = "slab_chunk_max", [TRACK_SIZES] = "track_sizes", [NO_INLINE_ASCII_RESP] = "no_inline_ascii_resp", [MODERN] = "modern", [NO_MODERN] = "no_modern", [NO_CHUNKED_ITEMS] = "no_chunked_items", [NO_SLAB_REASSIGN] = "no_slab_reassign", [NO_SLAB_AUTOMOVE] = "no_slab_automove", [NO_MAXCONNS_FAST] = "no_maxconns_fast", [INLINE_ASCII_RESP] = "inline_ascii_resp", [NO_LRU_CRAWLER] = "no_lru_crawler", [NO_LRU_MAINTAINER] = "no_lru_maintainer", [NO_DROP_PRIVILEGES] = "no_drop_privileges", [DROP_PRIVILEGES] = "drop_privileges", [RESP_OBJ_MEM_LIMIT] = "resp_obj_mem_limit", [READ_BUF_MEM_LIMIT] = "read_buf_mem_limit", #ifdef TLS [SSL_CERT] = "ssl_chain_cert", [SSL_KEY] = "ssl_key", [SSL_VERIFY_MODE] = "ssl_verify_mode", [SSL_KEYFORM] = "ssl_keyformat", [SSL_CIPHERS] = "ssl_ciphers", [SSL_CA_CERT] = "ssl_ca_cert", [SSL_WBUF_SIZE] = "ssl_wbuf_size", [SSL_SESSION_CACHE] = "ssl_session_cache", [SSL_KERNEL_TLS] = "ssl_kernel_tls", [SSL_MIN_VERSION] = "ssl_min_version", #endif #ifdef PROXY [PROXY_CONFIG] = "proxy_config", [PROXY_URING] = "proxy_uring", #endif #ifdef MEMCACHED_DEBUG [RELAXED_PRIVILEGES] = "relaxed_privileges", #endif #ifdef SOCK_COOKIE_ID [COOKIE_ID] = "sock_cookie_id", #endif NULL }; if (!sanitycheck()) { free(meta); return EX_OSERR; } /* handle SIGINT, SIGTERM */ signal(SIGINT, sig_handler); signal(SIGTERM, sig_handler); signal(SIGHUP, sighup_handler); signal(SIGUSR1, sig_usrhandler); /* init settings */ settings_init(); verify_default("hash_algorithm", hash_type == MURMUR3_HASH); #ifdef EXTSTORE void *storage = NULL; void *storage_cf = storage_init_config(&settings); bool storage_enabled = false; if (storage_cf == NULL) { fprintf(stderr, "failed to allocate extstore config\n"); return 1; } #endif /* set stderr non-buffering (for running under, say, daemontools) */ setbuf(stderr, NULL); char *shortopts = "a:" /* access mask for unix socket */ "A" /* enable admin shutdown command */ "Z" /* enable SSL */ "p:" /* TCP port number to listen on */ "s:" /* unix socket path to listen on */ "U:" /* UDP port number to listen on */ "m:" /* max memory to use for items in megabytes */ "M" /* return error on memory exhausted */ "c:" /* max simultaneous connections */ "k" /* lock down all paged memory */ "hiV" /* help, licence info, version */ "r" /* maximize core file limit */ "v" /* verbose */ "d" /* daemon mode */ "l:" /* interface to listen on */ "u:" /* user identity to run as */ "P:" /* save PID in file */ "f:" /* factor? */ "n:" /* minimum space allocated for key+value+flags */ "t:" /* threads */ "D:" /* prefix delimiter? */ "L" /* Large memory pages */ "R:" /* max requests per event */ "C" /* Disable use of CAS */ "b:" /* backlog queue limit */ "B:" /* Binding protocol */ "I:" /* Max item size */ "S" /* Sasl ON */ "F" /* Disable flush_all */ "X" /* Disable dump commands */ "W" /* Disable watch commands */ "Y:" /* Enable token auth */ "e:" /* mmap path for external item memory */ "o:" /* Extended generic options */ "N:" /* NAPI ID based thread selection */ ; /* process arguments */ #ifdef HAVE_GETOPT_LONG const struct option longopts[] = { {"unix-mask", required_argument, 0, 'a'}, {"enable-shutdown", no_argument, 0, 'A'}, {"enable-ssl", no_argument, 0, 'Z'}, {"port", required_argument, 0, 'p'}, {"unix-socket", required_argument, 0, 's'}, {"udp-port", required_argument, 0, 'U'}, {"memory-limit", required_argument, 0, 'm'}, {"disable-evictions", no_argument, 0, 'M'}, {"conn-limit", required_argument, 0, 'c'}, {"lock-memory", no_argument, 0, 'k'}, {"help", no_argument, 0, 'h'}, {"license", no_argument, 0, 'i'}, {"version", no_argument, 0, 'V'}, {"enable-coredumps", no_argument, 0, 'r'}, {"verbose", optional_argument, 0, 'v'}, {"daemon", no_argument, 0, 'd'}, {"listen", required_argument, 0, 'l'}, {"user", required_argument, 0, 'u'}, {"pidfile", required_argument, 0, 'P'}, {"slab-growth-factor", required_argument, 0, 'f'}, {"slab-min-size", required_argument, 0, 'n'}, {"threads", required_argument, 0, 't'}, {"enable-largepages", no_argument, 0, 'L'}, {"max-reqs-per-event", required_argument, 0, 'R'}, {"disable-cas", no_argument, 0, 'C'}, {"listen-backlog", required_argument, 0, 'b'}, {"protocol", required_argument, 0, 'B'}, {"max-item-size", required_argument, 0, 'I'}, {"enable-sasl", no_argument, 0, 'S'}, {"disable-flush-all", no_argument, 0, 'F'}, {"disable-dumping", no_argument, 0, 'X'}, {"disable-watch", no_argument, 0, 'W'}, {"auth-file", required_argument, 0, 'Y'}, {"memory-file", required_argument, 0, 'e'}, {"extended", required_argument, 0, 'o'}, {"napi-ids", required_argument, 0, 'N'}, {0, 0, 0, 0} }; int optindex; while (-1 != (c = getopt_long(argc, argv, shortopts, longopts, &optindex))) { #else while (-1 != (c = getopt(argc, argv, shortopts))) { #endif switch (c) { case 'A': /* enables "shutdown" command */ settings.shutdown_command = true; break; case 'Z': /* enable secure communication*/ #ifdef TLS settings.ssl_enabled = true; #else fprintf(stderr, "This server is not built with TLS support.\n"); exit(EX_USAGE); #endif break; case 'a': #ifndef DISABLE_UNIX_SOCKET /* access for unix domain socket, as octal mask (like chmod)*/ settings.access= strtol(optarg,NULL,8); #else fprintf(stderr, "This server is not built with unix socket support.\n"); exit(EX_USAGE); #endif /* #ifndef DISABLE_UNIX_SOCKET */ break; case 'U': settings.udpport = atoi(optarg); udp_specified = true; break; case 'p': settings.port = atoi(optarg); tcp_specified = true; break; case 's': #ifndef DISABLE_UNIX_SOCKET settings.socketpath = optarg; #else fprintf(stderr, "This server is not built with unix socket support.\n"); exit(EX_USAGE); #endif /* #ifndef DISABLE_UNIX_SOCKET */ break; case 'm': settings.maxbytes = ((size_t)atoi(optarg)) * 1024 * 1024; break; case 'M': settings.evict_to_free = 0; break; case 'c': settings.maxconns = atoi(optarg); if (settings.maxconns <= 0) { fprintf(stderr, "Maximum connections must be greater than 0\n"); return 1; } break; case 'h': usage(); exit(EXIT_SUCCESS); case 'i': usage_license(); exit(EXIT_SUCCESS); case 'V': printf(PACKAGE " " VERSION "\n"); exit(EXIT_SUCCESS); case 'k': lock_memory = true; break; case 'v': settings.verbose++; break; case 'l': if (settings.inter != NULL) { if (strstr(settings.inter, optarg) != NULL) { break; } size_t len = strlen(settings.inter) + strlen(optarg) + 2; char *p = malloc(len); if (p == NULL) { fprintf(stderr, "Failed to allocate memory\n"); return 1; } snprintf(p, len, "%s,%s", settings.inter, optarg); free(settings.inter); settings.inter = p; } else { settings.inter= strdup(optarg); } break; case 'd': do_daemonize = true; break; case 'r': maxcore = 1; break; case 'R': settings.reqs_per_event = atoi(optarg); if (settings.reqs_per_event == 0) { fprintf(stderr, "Number of requests per event must be greater than 0\n"); return 1; } break; case 'u': username = optarg; break; case 'P': pid_file = optarg; break; case 'e': settings.memory_file = optarg; break; case 'f': settings.factor = atof(optarg); if (settings.factor <= 1.0) { fprintf(stderr, "Factor must be greater than 1\n"); return 1; } meta->slab_config = strdup(optarg); break; case 'n': settings.chunk_size = atoi(optarg); if (settings.chunk_size == 0) { fprintf(stderr, "Chunk size must be greater than 0\n"); return 1; } break; case 't': settings.num_threads = atoi(optarg); if (settings.num_threads <= 0) { fprintf(stderr, "Number of threads must be greater than 0\n"); return 1; } /* There're other problems when you get above 64 threads. * In the future we should portably detect # of cores for the * default. */ if (settings.num_threads > 64) { fprintf(stderr, "WARNING: Setting a high number of worker" "threads is not recommended.\n" " Set this value to the number of cores in" " your machine or less.\n"); } break; case 'D': if (! optarg || ! optarg[0]) { fprintf(stderr, "No delimiter specified\n"); return 1; } settings.prefix_delimiter = optarg[0]; settings.detail_enabled = 1; break; case 'L' : if (enable_large_pages() == 0) { preallocate = true; } else { fprintf(stderr, "Cannot enable large pages on this system\n" "(There is no support as of this version)\n"); return 1; } break; case 'C' : settings.use_cas = false; break; case 'b' : settings.backlog = atoi(optarg); break; case 'B': protocol_specified = true; if (strcmp(optarg, "auto") == 0) { settings.binding_protocol = negotiating_prot; } else if (strcmp(optarg, "binary") == 0) { settings.binding_protocol = binary_prot; } else if (strcmp(optarg, "ascii") == 0) { settings.binding_protocol = ascii_prot; } else { fprintf(stderr, "Invalid value for binding protocol: %s\n" " -- should be one of auto, binary, or ascii\n", optarg); exit(EX_USAGE); } break; case 'I': buf = strdup(optarg); unit = buf[strlen(buf)-1]; if (unit == 'k' || unit == 'm' || unit == 'K' || unit == 'M') { buf[strlen(buf)-1] = '\0'; size_max = atoi(buf); if (unit == 'k' || unit == 'K') size_max *= 1024; if (unit == 'm' || unit == 'M') size_max *= 1024 * 1024; settings.item_size_max = size_max; } else { settings.item_size_max = atoi(buf); } free(buf); break; case 'S': /* set Sasl authentication to true. Default is false */ #ifndef ENABLE_SASL fprintf(stderr, "This server is not built with SASL support.\n"); exit(EX_USAGE); #endif settings.sasl = true; break; case 'F' : settings.flush_enabled = false; break; case 'X' : settings.dump_enabled = false; break; case 'W' : settings.watch_enabled = false; break; case 'Y' : // dupe the file path now just in case the options get mangled. settings.auth_file = strdup(optarg); break; case 'N': settings.num_napi_ids = atoi(optarg); if (settings.num_napi_ids <= 0) { fprintf(stderr, "Maximum number of NAPI IDs must be greater than 0\n"); return 1; } break; case 'o': /* It's sub-opts time! */ subopts_orig = subopts = strdup(optarg); /* getsubopt() changes the original args */ while (*subopts != '\0') { // BSD getsubopt (at least) has undefined behavior on -1, so // if we want to retry the getsubopt call in submodules we // need an extra layer of string copies. char *subopts_temp_o = NULL; char *subopts_temp = subopts_temp_o = strdup(subopts); switch (getsubopt(&subopts, subopts_tokens, &subopts_value)) { case MAXCONNS_FAST: settings.maxconns_fast = true; break; case HASHPOWER_INIT: if (subopts_value == NULL) { fprintf(stderr, "Missing numeric argument for hashpower\n"); return 1; } settings.hashpower_init = atoi(subopts_value); if (settings.hashpower_init < 12) { fprintf(stderr, "Initial hashtable multiplier of %d is too low\n", settings.hashpower_init); return 1; } else if (settings.hashpower_init > 32) { fprintf(stderr, "Initial hashtable multiplier of %d is too high\n" "Choose a value based on \"STAT hash_power_level\" from a running instance\n", settings.hashpower_init); return 1; } break; case NO_HASHEXPAND: start_assoc_maint = false; break; case SLAB_REASSIGN: settings.slab_reassign = true; break; case SLAB_AUTOMOVE: if (subopts_value == NULL) { settings.slab_automove = 1; break; } settings.slab_automove = atoi(subopts_value); if (settings.slab_automove < 0 || settings.slab_automove > 2) { fprintf(stderr, "slab_automove must be between 0 and 2\n"); return 1; } break; case SLAB_AUTOMOVE_RATIO: if (subopts_value == NULL) { fprintf(stderr, "Missing slab_automove_ratio argument\n"); return 1; } settings.slab_automove_ratio = atof(subopts_value); if (settings.slab_automove_ratio <= 0 || settings.slab_automove_ratio > 1) { fprintf(stderr, "slab_automove_ratio must be > 0 and < 1\n"); return 1; } break; case SLAB_AUTOMOVE_WINDOW: if (subopts_value == NULL) { fprintf(stderr, "Missing slab_automove_window argument\n"); return 1; } settings.slab_automove_window = atoi(subopts_value); if (settings.slab_automove_window < 3) { fprintf(stderr, "slab_automove_window must be > 2\n"); return 1; } break; case TAIL_REPAIR_TIME: if (subopts_value == NULL) { fprintf(stderr, "Missing numeric argument for tail_repair_time\n"); return 1; } settings.tail_repair_time = atoi(subopts_value); if (settings.tail_repair_time < 10) { fprintf(stderr, "Cannot set tail_repair_time to less than 10 seconds\n"); return 1; } break; case HASH_ALGORITHM: if (subopts_value == NULL) { fprintf(stderr, "Missing hash_algorithm argument\n"); return 1; }; if (strcmp(subopts_value, "jenkins") == 0) { hash_type = JENKINS_HASH; } else if (strcmp(subopts_value, "murmur3") == 0) { hash_type = MURMUR3_HASH; } else if (strcmp(subopts_value, "xxh3") == 0) { hash_type = XXH3_HASH; } else { fprintf(stderr, "Unknown hash_algorithm option (jenkins, murmur3, xxh3)\n"); return 1; } break; case LRU_CRAWLER: start_lru_crawler = true; break; case LRU_CRAWLER_SLEEP: if (subopts_value == NULL) { fprintf(stderr, "Missing lru_crawler_sleep value\n"); return 1; } settings.lru_crawler_sleep = atoi(subopts_value); if (settings.lru_crawler_sleep > 1000000 || settings.lru_crawler_sleep < 0) { fprintf(stderr, "LRU crawler sleep must be between 0 and 1 second\n"); return 1; } break; case LRU_CRAWLER_TOCRAWL: if (subopts_value == NULL) { fprintf(stderr, "Missing lru_crawler_tocrawl value\n"); return 1; } if (!safe_strtoul(subopts_value, &tocrawl)) { fprintf(stderr, "lru_crawler_tocrawl takes a numeric 32bit value\n"); return 1; } settings.lru_crawler_tocrawl = tocrawl; break; case LRU_MAINTAINER: start_lru_maintainer = true; settings.lru_segmented = true; break; case HOT_LRU_PCT: if (subopts_value == NULL) { fprintf(stderr, "Missing hot_lru_pct argument\n"); return 1; } settings.hot_lru_pct = atoi(subopts_value); if (settings.hot_lru_pct < 1 || settings.hot_lru_pct >= 80) { fprintf(stderr, "hot_lru_pct must be > 1 and < 80\n"); return 1; } break; case WARM_LRU_PCT: if (subopts_value == NULL) { fprintf(stderr, "Missing warm_lru_pct argument\n"); return 1; } settings.warm_lru_pct = atoi(subopts_value); if (settings.warm_lru_pct < 1 || settings.warm_lru_pct >= 80) { fprintf(stderr, "warm_lru_pct must be > 1 and < 80\n"); return 1; } break; case HOT_MAX_FACTOR: if (subopts_value == NULL) { fprintf(stderr, "Missing hot_max_factor argument\n"); return 1; } settings.hot_max_factor = atof(subopts_value); if (settings.hot_max_factor <= 0) { fprintf(stderr, "hot_max_factor must be > 0\n"); return 1; } break; case WARM_MAX_FACTOR: if (subopts_value == NULL) { fprintf(stderr, "Missing warm_max_factor argument\n"); return 1; } settings.warm_max_factor = atof(subopts_value); if (settings.warm_max_factor <= 0) { fprintf(stderr, "warm_max_factor must be > 0\n"); return 1; } break; case TEMPORARY_TTL: if (subopts_value == NULL) { fprintf(stderr, "Missing temporary_ttl argument\n"); return 1; } settings.temp_lru = true; settings.temporary_ttl = atoi(subopts_value); break; case IDLE_TIMEOUT: if (subopts_value == NULL) { fprintf(stderr, "Missing numeric argument for idle_timeout\n"); return 1; } settings.idle_timeout = atoi(subopts_value); break; case WATCHER_LOGBUF_SIZE: if (subopts_value == NULL) { fprintf(stderr, "Missing watcher_logbuf_size argument\n"); return 1; } if (!safe_strtoul(subopts_value, &settings.logger_watcher_buf_size)) { fprintf(stderr, "could not parse argument to watcher_logbuf_size\n"); return 1; } settings.logger_watcher_buf_size *= 1024; /* kilobytes */ break; case WORKER_LOGBUF_SIZE: if (subopts_value == NULL) { fprintf(stderr, "Missing worker_logbuf_size argument\n"); return 1; } if (!safe_strtoul(subopts_value, &settings.logger_buf_size)) { fprintf(stderr, "could not parse argument to worker_logbuf_size\n"); return 1; } settings.logger_buf_size *= 1024; /* kilobytes */ case SLAB_SIZES: slab_sizes_unparsed = strdup(subopts_value); break; case SLAB_CHUNK_MAX: if (subopts_value == NULL) { fprintf(stderr, "Missing slab_chunk_max argument\n"); } if (!safe_strtol(subopts_value, &settings.slab_chunk_size_max)) { fprintf(stderr, "could not parse argument to slab_chunk_max\n"); } slab_chunk_size_changed = true; break; case TRACK_SIZES: item_stats_sizes_init(); break; case NO_INLINE_ASCII_RESP: break; case INLINE_ASCII_RESP: break; case NO_CHUNKED_ITEMS: settings.slab_chunk_size_max = settings.slab_page_size; break; case NO_SLAB_REASSIGN: settings.slab_reassign = false; break; case NO_SLAB_AUTOMOVE: settings.slab_automove = 0; break; case NO_MAXCONNS_FAST: settings.maxconns_fast = false; break; case NO_LRU_CRAWLER: settings.lru_crawler = false; start_lru_crawler = false; break; case NO_LRU_MAINTAINER: start_lru_maintainer = false; settings.lru_segmented = false; break; #ifdef TLS case SSL_CERT: if (subopts_value == NULL) { fprintf(stderr, "Missing ssl_chain_cert argument\n"); return 1; } settings.ssl_chain_cert = strdup(subopts_value); break; case SSL_KEY: if (subopts_value == NULL) { fprintf(stderr, "Missing ssl_key argument\n"); return 1; } settings.ssl_key = strdup(subopts_value); break; case SSL_VERIFY_MODE: { if (subopts_value == NULL) { fprintf(stderr, "Missing ssl_verify_mode argument\n"); return 1; } int verify = 0; if (!safe_strtol(subopts_value, &verify)) { fprintf(stderr, "could not parse argument to ssl_verify_mode\n"); return 1; } switch(verify) { case 0: settings.ssl_verify_mode = SSL_VERIFY_NONE; break; case 1: settings.ssl_verify_mode = SSL_VERIFY_PEER; break; case 2: settings.ssl_verify_mode = SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT; break; case 3: settings.ssl_verify_mode = SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT | SSL_VERIFY_CLIENT_ONCE; break; default: fprintf(stderr, "Invalid ssl_verify_mode. Use help to see valid options.\n"); return 1; } break; } case SSL_KEYFORM: if (subopts_value == NULL) { fprintf(stderr, "Missing ssl_keyformat argument\n"); return 1; } if (!safe_strtol(subopts_value, &settings.ssl_keyformat)) { fprintf(stderr, "could not parse argument to ssl_keyformat\n"); return 1; } break; case SSL_CIPHERS: if (subopts_value == NULL) { fprintf(stderr, "Missing ssl_ciphers argument\n"); return 1; } settings.ssl_ciphers = strdup(subopts_value); break; case SSL_CA_CERT: if (subopts_value == NULL) { fprintf(stderr, "Missing ssl_ca_cert argument\n"); return 1; } settings.ssl_ca_cert = strdup(subopts_value); break; case SSL_WBUF_SIZE: if (subopts_value == NULL) { fprintf(stderr, "Missing ssl_wbuf_size argument\n"); return 1; } if (!safe_strtoul(subopts_value, &settings.ssl_wbuf_size)) { fprintf(stderr, "could not parse argument to ssl_wbuf_size\n"); return 1; } settings.ssl_wbuf_size *= 1024; /* kilobytes */ break; case SSL_SESSION_CACHE: settings.ssl_session_cache = true; break; case SSL_KERNEL_TLS: settings.ssl_kernel_tls = true; break; case SSL_MIN_VERSION: { int min_version; if (subopts_value == NULL) { fprintf(stderr, "Missing ssl_min_version argument\n"); return 1; } if (!safe_strtol(subopts_value, &min_version)) { fprintf(stderr, "could not parse argument to ssl_min_version\n"); return 1; } switch (min_version) { case 0: settings.ssl_min_version = TLS1_VERSION; break; case 1: settings.ssl_min_version = TLS1_1_VERSION; break; case 2: settings.ssl_min_version = TLS1_2_VERSION; break; #if defined(TLS1_3_VERSION) case 3: settings.ssl_min_version = TLS1_3_VERSION; break; #endif default: fprintf(stderr, "Invalid ssl_min_version. Use help to see valid options.\n"); return 1; } break; } #endif case MODERN: /* currently no new defaults */ break; case NO_MODERN: if (!slab_chunk_size_changed) { settings.slab_chunk_size_max = settings.slab_page_size; } settings.slab_reassign = false; settings.slab_automove = 0; settings.maxconns_fast = false; settings.lru_segmented = false; hash_type = JENKINS_HASH; start_lru_crawler = false; start_lru_maintainer = false; break; case NO_DROP_PRIVILEGES: settings.drop_privileges = false; break; case DROP_PRIVILEGES: settings.drop_privileges = true; break; case RESP_OBJ_MEM_LIMIT: // TODO: Remove at some point in the future. fprintf(stderr, "DEPRECATED: resp_obj_mem_limit no longer used. See read_buf_mem_limit,\n"); break; case READ_BUF_MEM_LIMIT: if (subopts_value == NULL) { fprintf(stderr, "Missing read_buf_mem_limit argument\n"); return 1; } if (!safe_strtoul(subopts_value, &settings.read_buf_mem_limit)) { fprintf(stderr, "could not parse argument to read_buf_mem_limit\n"); return 1; } settings.read_buf_mem_limit *= 1024 * 1024; /* megabytes */ break; #ifdef PROXY case PROXY_CONFIG: if (subopts_value == NULL) { fprintf(stderr, "Missing proxy_config file argument\n"); return 1; } if (protocol_specified) { fprintf(stderr, "Cannot specify a protocol with proxy mode enabled\n"); return 1; } settings.proxy_startfile = strdup(subopts_value); settings.proxy_enabled = true; settings.binding_protocol = proxy_prot; protocol_specified = true; break; case PROXY_URING: settings.proxy_uring = true; break; #endif #ifdef MEMCACHED_DEBUG case RELAXED_PRIVILEGES: settings.relaxed_privileges = true; break; #endif #ifdef SOCK_COOKIE_ID case COOKIE_ID: (void)safe_strtoul(subopts_value, &settings.sock_cookie_id); break; #endif default: #ifdef EXTSTORE // TODO: differentiating response code. if (storage_read_config(storage_cf, &subopts_temp)) { return 1; } #else printf("Illegal suboption \"%s\"\n", subopts_temp); return 1; #endif } // switch if (subopts_temp_o) { free(subopts_temp_o); } } // while free(subopts_orig); break; default: fprintf(stderr, "Illegal argument \"%c\"\n", c); return 1; } } if (settings.num_napi_ids > settings.num_threads) { fprintf(stderr, "Number of napi_ids(%d) cannot be greater than number of threads(%d)\n", settings.num_napi_ids, settings.num_threads); exit(EX_USAGE); } if (settings.item_size_max < ITEM_SIZE_MAX_LOWER_LIMIT) { fprintf(stderr, "Item max size cannot be less than 1024 bytes.\n"); exit(EX_USAGE); } if (settings.item_size_max > (settings.maxbytes / 2)) { fprintf(stderr, "Cannot set item size limit higher than 1/2 of memory max.\n"); exit(EX_USAGE); } if (settings.item_size_max > (ITEM_SIZE_MAX_UPPER_LIMIT)) { fprintf(stderr, "Cannot set item size limit higher than a gigabyte.\n"); exit(EX_USAGE); } if (settings.item_size_max > 1024 * 1024) { if (!slab_chunk_size_changed) { // Ideal new default is 16k, but needs stitching. settings.slab_chunk_size_max = settings.slab_page_size / 2; } } if (settings.slab_chunk_size_max > settings.item_size_max) { fprintf(stderr, "slab_chunk_max (bytes: %d) cannot be larger than -I (item_size_max %d)\n", settings.slab_chunk_size_max, settings.item_size_max); exit(EX_USAGE); } if (settings.item_size_max % settings.slab_chunk_size_max != 0) { fprintf(stderr, "-I (item_size_max: %d) must be evenly divisible by slab_chunk_max (bytes: %d)\n", settings.item_size_max, settings.slab_chunk_size_max); exit(EX_USAGE); } if (settings.slab_page_size % settings.slab_chunk_size_max != 0) { fprintf(stderr, "slab_chunk_max (bytes: %d) must divide evenly into %d (slab_page_size)\n", settings.slab_chunk_size_max, settings.slab_page_size); exit(EX_USAGE); } #ifdef EXTSTORE switch (storage_check_config(storage_cf)) { case 0: storage_enabled = true; break; case 1: exit(EX_USAGE); break; } #endif // Reserve this for the new default. If factor size hasn't changed, use // new default. /*if (settings.slab_chunk_size_max == 16384 && settings.factor == 1.25) { settings.factor = 1.08; }*/ if (slab_sizes_unparsed != NULL) { // want the unedited string for restart code. char *temp = strdup(slab_sizes_unparsed); if (_parse_slab_sizes(slab_sizes_unparsed, slab_sizes)) { use_slab_sizes = true; if (meta->slab_config) { free(meta->slab_config); } meta->slab_config = temp; } else { exit(EX_USAGE); } } else if (!meta->slab_config) { // using the default factor. meta->slab_config = "1.25"; } if (settings.hot_lru_pct + settings.warm_lru_pct > 80) { fprintf(stderr, "hot_lru_pct + warm_lru_pct cannot be more than 80%% combined\n"); exit(EX_USAGE); } if (settings.temp_lru && !start_lru_maintainer) { fprintf(stderr, "temporary_ttl requires lru_maintainer to be enabled\n"); exit(EX_USAGE); } if (hash_init(hash_type) != 0) { fprintf(stderr, "Failed to initialize hash_algorithm!\n"); exit(EX_USAGE); } /* * Use one workerthread to serve each UDP port if the user specified * multiple ports */ if (settings.inter != NULL && strchr(settings.inter, ',')) { settings.num_threads_per_udp = 1; } else { settings.num_threads_per_udp = settings.num_threads; } if (settings.sasl) { if (!protocol_specified) { settings.binding_protocol = binary_prot; } else { if (settings.binding_protocol != binary_prot) { fprintf(stderr, "ERROR: You cannot allow the ASCII protocol while using SASL.\n"); exit(EX_USAGE); } } if (settings.udpport) { fprintf(stderr, "ERROR: Cannot enable UDP while using binary SASL authentication.\n"); exit(EX_USAGE); } } if (settings.auth_file) { if (!protocol_specified) { settings.binding_protocol = ascii_prot; } else { if (settings.binding_protocol != ascii_prot) { fprintf(stderr, "ERROR: You cannot allow the BINARY protocol while using ascii authentication tokens.\n"); exit(EX_USAGE); } } } if (udp_specified && settings.udpport != 0 && !tcp_specified) { settings.port = settings.udpport; } if (settings.port > 65535) { fprintf(stderr, "ERROR: Invalid port number %d.\n", settings.port); exit(EX_USAGE); } #ifdef TLS /* * Setup SSL if enabled */ if (settings.ssl_enabled) { if (!settings.port) { fprintf(stderr, "ERROR: You cannot enable SSL without a TCP port.\n"); exit(EX_USAGE); } // openssl init methods. SSL_load_error_strings(); SSLeay_add_ssl_algorithms(); // Initiate the SSL context. ssl_init(); } #endif if (maxcore != 0) { struct rlimit rlim_new; /* * First try raising to infinity; if that fails, try bringing * the soft limit to the hard. */ if (getrlimit(RLIMIT_CORE, &rlim) == 0) { rlim_new.rlim_cur = rlim_new.rlim_max = RLIM_INFINITY; if (setrlimit(RLIMIT_CORE, &rlim_new)!= 0) { /* failed. try raising just to the old max */ rlim_new.rlim_cur = rlim_new.rlim_max = rlim.rlim_max; (void)setrlimit(RLIMIT_CORE, &rlim_new); } } /* * getrlimit again to see what we ended up with. Only fail if * the soft limit ends up 0, because then no core files will be * created at all. */ if ((getrlimit(RLIMIT_CORE, &rlim) != 0) || rlim.rlim_cur == 0) { fprintf(stderr, "failed to ensure corefile creation\n"); exit(EX_OSERR); } } /* * If needed, increase rlimits to allow as many connections * as needed. */ if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) { fprintf(stderr, "failed to getrlimit number of files\n"); exit(EX_OSERR); } else { rlim.rlim_cur = settings.maxconns; rlim.rlim_max = settings.maxconns; if (setrlimit(RLIMIT_NOFILE, &rlim) != 0) { #ifndef MEMCACHED_DEBUG fprintf(stderr, "failed to set rlimit for open files. Try starting as root or requesting smaller maxconns value.\n"); exit(EX_OSERR); #endif } } /* lose root privileges if we have them */ if (getuid() == 0 || geteuid() == 0) { if (username == 0 || *username == '\0') { fprintf(stderr, "can't run as root without the -u switch\n"); exit(EX_USAGE); } if ((pw = getpwnam(username)) == 0) { fprintf(stderr, "can't find the user %s to switch to\n", username); exit(EX_NOUSER); } if (setgroups(0, NULL) < 0) { /* setgroups may fail with EPERM, indicating we are already in a * minimally-privileged state. In that case we continue. For all * other failure codes we exit. * * Note that errno is stored here because fprintf may change it. */ bool should_exit = errno != EPERM; fprintf(stderr, "failed to drop supplementary groups: %s\n", strerror(errno)); if (should_exit) { exit(EX_OSERR); } } if (setgid(pw->pw_gid) < 0 || setuid(pw->pw_uid) < 0) { fprintf(stderr, "failed to assume identity of user %s\n", username); exit(EX_OSERR); } } /* Initialize Sasl if -S was specified */ if (settings.sasl) { init_sasl(); } /* daemonize if requested */ /* if we want to ensure our ability to dump core, don't chdir to / */ if (do_daemonize) { if (signal(SIGHUP, SIG_IGN) == SIG_ERR) { perror("Failed to ignore SIGHUP"); } if (daemonize(maxcore, settings.verbose) == -1) { fprintf(stderr, "failed to daemon() in order to daemonize\n"); exit(EXIT_FAILURE); } } /* lock paged memory if needed */ if (lock_memory) { #ifdef HAVE_MLOCKALL int res = mlockall(MCL_CURRENT | MCL_FUTURE); if (res != 0) { fprintf(stderr, "warning: -k invalid, mlockall() failed: %s\n", strerror(errno)); } #else fprintf(stderr, "warning: -k invalid, mlockall() not supported on this platform. proceeding without.\n"); #endif } /* initialize main thread libevent instance */ #if defined(LIBEVENT_VERSION_NUMBER) && LIBEVENT_VERSION_NUMBER >= 0x02000101 /* If libevent version is larger/equal to 2.0.2-alpha, use newer version */ struct event_config *ev_config; ev_config = event_config_new(); event_config_set_flag(ev_config, EVENT_BASE_FLAG_NOLOCK); main_base = event_base_new_with_config(ev_config); event_config_free(ev_config); #else /* Otherwise, use older API */ main_base = event_init(); #endif /* Load initial auth file if required */ if (settings.auth_file) { if (settings.udpport) { fprintf(stderr, "Cannot use UDP with ascii authentication enabled (-U 0 to disable)\n"); exit(EX_USAGE); } switch (authfile_load(settings.auth_file)) { case AUTHFILE_STATFAIL: vperror("Could not stat authfile [%s], error %s", settings.auth_file , strerror(errno)); exit(EXIT_FAILURE); break; case AUTHFILE_OPENFAIL: vperror("Could not open authfile [%s] for reading, error %s", settings.auth_file , strerror(errno)); exit(EXIT_FAILURE); break; case AUTHFILE_OOM: fprintf(stderr, "Out of memory reading password file: %s", settings.auth_file); exit(EXIT_FAILURE); break; case AUTHFILE_MALFORMED: fprintf(stderr, "Authfile [%s] has a malformed entry. Should be 'user:password'", settings.auth_file); exit(EXIT_FAILURE); break; case AUTHFILE_OK: break; } } /* initialize other stuff */ stats_init(); logger_init(); conn_init(); bool reuse_mem = false; void *mem_base = NULL; bool prefill = false; if (settings.memory_file != NULL) { preallocate = true; // Easier to manage memory if we prefill the global pool when reusing. prefill = true; restart_register("main", _mc_meta_load_cb, _mc_meta_save_cb, meta); reuse_mem = restart_mmap_open(settings.maxbytes, settings.memory_file, &mem_base); // The "save" callback gets called when we're closing out the mmap, // but we don't know what the mmap_base is until after we call open. // So we pass the struct above but have to fill it in here so the // data's available during the save routine. meta->mmap_base = mem_base; // Also, the callbacks for load() run before _open returns, so we // should have the old base in 'meta' as of here. } // Initialize the hash table _after_ checking restart metadata. // We override the hash table start argument with what was live // previously, to avoid filling a huge set of items into a tiny hash // table. assoc_init(settings.hashpower_init); #ifdef EXTSTORE if (storage_enabled && reuse_mem) { fprintf(stderr, "[restart] memory restart with extstore not presently supported.\n"); reuse_mem = false; } #endif slabs_init(settings.maxbytes, settings.factor, preallocate, use_slab_sizes ? slab_sizes : NULL, mem_base, reuse_mem); #ifdef EXTSTORE if (storage_enabled) { storage = storage_init(storage_cf); if (storage == NULL) { exit(EXIT_FAILURE); } ext_storage = storage; /* page mover algorithm for extstore needs memory prefilled */ prefill = true; } #endif if (settings.drop_privileges) { setup_privilege_violations_handler(); } if (prefill) slabs_prefill_global(); /* In restartable mode and we've decided to issue a fixup on memory */ if (settings.memory_file != NULL && reuse_mem) { mc_ptr_t old_base = meta->old_base; assert(old_base == meta->old_base); // should've pulled in process_started from meta file. process_started = meta->process_started; // TODO: must be a more canonical way of serializing/deserializing // pointers? passing through uint64_t should work, and we're not // annotating the pointer with anything, but it's still slightly // insane. restart_fixup((void *)old_base); } /* * ignore SIGPIPE signals; we can use errno == EPIPE if we * need that information */ if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) { perror("failed to ignore SIGPIPE; sigaction"); exit(EX_OSERR); } /* start up worker threads if MT mode */ #ifdef PROXY if (settings.proxy_enabled) { settings.proxy_ctx = proxy_init(settings.proxy_uring); } #endif #ifdef EXTSTORE slabs_set_storage(storage); memcached_thread_init(settings.num_threads, storage); init_lru_crawler(storage); #else memcached_thread_init(settings.num_threads, NULL); init_lru_crawler(NULL); #endif #ifdef PROXY if (settings.proxy_enabled) { if (proxy_first_confload(settings.proxy_ctx) != 0) { exit(EXIT_FAILURE); } } #endif if (start_assoc_maint && start_assoc_maintenance_thread() == -1) { exit(EXIT_FAILURE); } if (start_lru_crawler && start_item_crawler_thread() != 0) { fprintf(stderr, "Failed to enable LRU crawler thread\n"); exit(EXIT_FAILURE); } #ifdef EXTSTORE if (storage && start_storage_compact_thread(storage) != 0) { fprintf(stderr, "Failed to start storage compaction thread\n"); exit(EXIT_FAILURE); } if (storage && start_storage_write_thread(storage) != 0) { fprintf(stderr, "Failed to start storage writer thread\n"); exit(EXIT_FAILURE); } if (start_lru_maintainer && start_lru_maintainer_thread(storage) != 0) { #else if (start_lru_maintainer && start_lru_maintainer_thread(NULL) != 0) { #endif fprintf(stderr, "Failed to enable LRU maintainer thread\n"); free(meta); return 1; } if (settings.slab_reassign && start_slab_maintenance_thread() == -1) { exit(EXIT_FAILURE); } if (settings.idle_timeout && start_conn_timeout_thread() == -1) { exit(EXIT_FAILURE); } /* initialise clock event */ #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) { struct timespec ts; if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) { monotonic = true; monotonic_start = ts.tv_sec; // Monotonic clock needs special handling for restarts. // We get a start time at an arbitrary place, so we need to // restore the original time delta, which is always "now" - _start if (reuse_mem) { // the running timespan at stop time + the time we think we // were stopped. monotonic_start -= meta->current_time + meta->time_delta; } else { monotonic_start -= ITEM_UPDATE_INTERVAL + 2; } } } #endif clock_handler(0, 0, 0); /* create unix mode sockets after dropping privileges */ if (settings.socketpath != NULL) { errno = 0; if (server_socket_unix(settings.socketpath,settings.access)) { vperror("failed to listen on UNIX socket: %s", settings.socketpath); exit(EX_OSERR); } } /* create the listening socket, bind it, and init */ if (settings.socketpath == NULL) { const char *portnumber_filename = getenv("MEMCACHED_PORT_FILENAME"); char *temp_portnumber_filename = NULL; size_t len; FILE *portnumber_file = NULL; if (portnumber_filename != NULL) { len = strlen(portnumber_filename)+4+1; temp_portnumber_filename = malloc(len); snprintf(temp_portnumber_filename, len, "%s.lck", portnumber_filename); portnumber_file = fopen(temp_portnumber_filename, "a"); if (portnumber_file == NULL) { fprintf(stderr, "Failed to open \"%s\": %s\n", temp_portnumber_filename, strerror(errno)); } } errno = 0; if (settings.port && server_sockets(settings.port, tcp_transport, portnumber_file)) { if (settings.inter == NULL) { vperror("failed to listen on TCP port %d", settings.port); } else { vperror("failed to listen on one of interface(s) %s", settings.inter); } exit(EX_OSERR); } /* * initialization order: first create the listening sockets * (may need root on low ports), then drop root if needed, * then daemonize if needed, then init libevent (in some cases * descriptors created by libevent wouldn't survive forking). */ /* create the UDP listening socket and bind it */ errno = 0; if (settings.udpport && server_sockets(settings.udpport, udp_transport, portnumber_file)) { if (settings.inter == NULL) { vperror("failed to listen on UDP port %d", settings.udpport); } else { vperror("failed to listen on one of interface(s) %s", settings.inter); } exit(EX_OSERR); } if (portnumber_file) { fclose(portnumber_file); rename(temp_portnumber_filename, portnumber_filename); } if (temp_portnumber_filename) free(temp_portnumber_filename); } /* Give the sockets a moment to open. I know this is dumb, but the error * is only an advisory. */ usleep(1000); if (stats_state.curr_conns + stats_state.reserved_fds >= settings.maxconns - 1) { fprintf(stderr, "Maxconns setting is too low, use -c to increase.\n"); exit(EXIT_FAILURE); } if (pid_file != NULL) { save_pid(pid_file); } /* Drop privileges no longer needed */ if (settings.drop_privileges) { drop_privileges(); } /* Initialize the uriencode lookup table. */ uriencode_init(); /* enter the event loop */ while (!stop_main_loop) { if (event_base_loop(main_base, EVLOOP_ONCE) != 0) { retval = EXIT_FAILURE; break; } } switch (stop_main_loop) { case GRACE_STOP: fprintf(stderr, "Gracefully stopping\n"); break; case EXIT_NORMALLY: // Don't need to print anything to STDERR for a normal shutdown except // if we want to. if (settings.verbose) { fprintf(stderr, "Exiting normally\n"); } break; default: fprintf(stderr, "Exiting on error\n"); break; } if (stop_main_loop == GRACE_STOP) { stop_threads(); if (settings.memory_file != NULL) { restart_mmap_close(); } } /* remove the PID file if we're a daemon */ if (do_daemonize) remove_pidfile(pid_file); /* Clean up strdup() call for bind() address */ if (settings.inter) free(settings.inter); /* cleanup base */ event_base_free(main_base); free(meta); return retval; } memcached-1.6.20/sasl_defs.c0000664000175000017500000001407314204760331012545 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "memcached.h" #include #include #include #include char my_sasl_hostname[1025]; #if defined(HAVE_SASL_CB_GETCONF) || defined(HAVE_SASL_CB_GETCONFPATH) /* The locations we may search for a SASL config file if the user didn't * specify one in the environment variable SASL_CONF_PATH */ const char * const locations[] = { "/etc/sasl/memcached.conf", "/etc/sasl2/memcached.conf", NULL }; /* If the element of locations is file, locations_dir_path stores the * directory path of these elements */ const char *const locations_dir_path[] = { "/etc/sasl", "/etc/sasl2", NULL }; /* If the element of locations is directory, locations_file_path stores * the actual configure file which used by sasl, when GETCONFPATH is * enabled */ const char *const locations_file_path[] = { "/etc/sasl/memcached.conf/memcached.conf", "/etc/sasl2/memcached.conf/memcached.conf", NULL }; #endif #ifndef HAVE_SASL_CALLBACK_FT typedef int (*sasl_callback_ft)(void); #endif #ifdef ENABLE_SASL_PWDB #define MAX_ENTRY_LEN 256 static const char *memcached_sasl_pwdb; static int sasl_server_userdb_checkpass(sasl_conn_t *conn, void *context, const char *user, const char *pass, unsigned passlen, struct propctx *propctx) { size_t unmlen = strlen(user); if ((passlen + unmlen) > (MAX_ENTRY_LEN - 4)) { fprintf(stderr, "WARNING: Failed to authenticate <%s> due to too long password (%d)\n", user, passlen); return SASL_NOAUTHZ; } FILE *pwfile = fopen(memcached_sasl_pwdb, "r"); if (pwfile == NULL) { if (settings.verbose) { vperror("WARNING: Failed to open sasl database <%s>", memcached_sasl_pwdb); } return SASL_NOAUTHZ; } char buffer[MAX_ENTRY_LEN]; bool ok = false; while ((fgets(buffer, sizeof(buffer), pwfile)) != NULL) { if (memcmp(user, buffer, unmlen) == 0 && buffer[unmlen] == ':') { /* This is the correct user */ ++unmlen; if (memcmp(pass, buffer + unmlen, passlen) == 0 && (buffer[unmlen + passlen] == ':' || /* Additional tokens */ buffer[unmlen + passlen] == '\n' || /* end of line */ buffer[unmlen + passlen] == '\r'|| /* dos format? */ buffer[unmlen + passlen] == '\0')) { /* line truncated */ ok = true; } break; } } (void)fclose(pwfile); if (ok) { return SASL_OK; } if (settings.verbose) { fprintf(stderr, "INFO: User <%s> failed to authenticate\n", user); } return SASL_NOAUTHZ; } #endif #if defined(HAVE_SASL_CB_GETCONF) || defined(HAVE_SASL_CB_GETCONFPATH) static int sasl_getconf(void *context, const char **path) { *path = getenv("SASL_CONF_PATH"); if (*path == NULL) { #if defined(HAVE_SASL_CB_GETCONF) for (int i = 0; locations[i] != NULL; ++i) { if (access(locations[i], F_OK) == 0) { *path = locations[i]; break; } } #elif defined(HAVE_SASL_CB_GETCONFPATH) for (int i = 0; locations[i] != NULL; ++i) { if (access(locations_file_path[i], F_OK) == 0) { *path = locations[i]; break; } else if (access(locations[i], F_OK) == 0) { *path = locations_dir_path[i]; break; } } #endif } if (settings.verbose) { if (*path != NULL) { fprintf(stderr, "Reading configuration from: <%s>\n", *path); } else { fprintf(stderr, "Failed to locate a config path\n"); } } return (*path != NULL) ? SASL_OK : SASL_FAIL; } #endif static int sasl_log(void *context, int level, const char *message) { bool log = true; switch (level) { case SASL_LOG_NONE: log = false; break; case SASL_LOG_PASS: case SASL_LOG_TRACE: case SASL_LOG_DEBUG: case SASL_LOG_NOTE: if (settings.verbose < 2) { log = false; } break; case SASL_LOG_WARN: case SASL_LOG_FAIL: if (settings.verbose < 1) { log = false; } break; default: /* This is an error */ ; } if (log) { fprintf(stderr, "SASL (severity %d): %s\n", level, message); } return SASL_OK; } static sasl_callback_t sasl_callbacks[] = { #ifdef ENABLE_SASL_PWDB { SASL_CB_SERVER_USERDB_CHECKPASS, (sasl_callback_ft)sasl_server_userdb_checkpass, NULL }, #endif { SASL_CB_LOG, (sasl_callback_ft)sasl_log, NULL }, #ifdef HAVE_SASL_CB_GETCONF { SASL_CB_GETCONF, sasl_getconf, NULL }, #else #ifdef HAVE_SASL_CB_GETCONFPATH { SASL_CB_GETCONFPATH, (sasl_callback_ft)sasl_getconf, NULL }, #endif #endif { SASL_CB_LIST_END, NULL, NULL } }; void init_sasl(void) { #ifdef ENABLE_SASL_PWDB memcached_sasl_pwdb = getenv("MEMCACHED_SASL_PWDB"); if (memcached_sasl_pwdb == NULL) { if (settings.verbose) { fprintf(stderr, "INFO: MEMCACHED_SASL_PWDB not specified. " "Internal passwd database disabled\n"); } sasl_callbacks[0].id = SASL_CB_LIST_END; sasl_callbacks[0].proc = NULL; } #endif memset(my_sasl_hostname, 0, sizeof(my_sasl_hostname)); if (gethostname(my_sasl_hostname, sizeof(my_sasl_hostname)-1) == -1) { if (settings.verbose) { fprintf(stderr, "Error discovering hostname for SASL\n"); } my_sasl_hostname[0] = '\0'; } if (sasl_server_init(sasl_callbacks, "memcached") != SASL_OK) { fprintf(stderr, "Error initializing sasl.\n"); exit(EXIT_FAILURE); } else { if (settings.verbose) { fprintf(stderr, "Initialized SASL.\n"); } } } memcached-1.6.20/storage.c0000664000175000017500000014402514427543277012266 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "memcached.h" #ifdef EXTSTORE #include "storage.h" #include "extstore.h" #include #include #include #include #include #include #define PAGE_BUCKET_DEFAULT 0 #define PAGE_BUCKET_COMPACT 1 #define PAGE_BUCKET_CHUNKED 2 #define PAGE_BUCKET_LOWTTL 3 /* * API functions */ static void storage_finalize_cb(io_pending_t *pending); static void storage_return_cb(io_pending_t *pending); // re-cast an io_pending_t into this more descriptive structure. // the first few items _must_ match the original struct. typedef struct _io_pending_storage_t { int io_queue_type; LIBEVENT_THREAD *thread; conn *c; mc_resp *resp; io_queue_cb return_cb; // called on worker thread. io_queue_cb finalize_cb; // called back on the worker thread. /* original struct ends here */ item *hdr_it; /* original header item. */ obj_io io_ctx; /* embedded extstore IO header */ unsigned int iovec_data; /* specific index of data iovec */ bool noreply; /* whether the response had noreply set */ bool miss; /* signal a miss to unlink hdr_it */ bool badcrc; /* signal a crc failure */ bool active; /* tells if IO was dispatched or not */ } io_pending_storage_t; // Only call this if item has ITEM_HDR bool storage_validate_item(void *e, item *it) { item_hdr *hdr = (item_hdr *)ITEM_data(it); if (extstore_check(e, hdr->page_id, hdr->page_version) != 0) { return false; } else { return true; } } void storage_delete(void *e, item *it) { if (it->it_flags & ITEM_HDR) { item_hdr *hdr = (item_hdr *)ITEM_data(it); extstore_delete(e, hdr->page_id, hdr->page_version, 1, ITEM_ntotal(it)); } } // Function for the extra stats called from a protocol. // NOTE: This either needs a name change or a wrapper, perhaps? // it's defined here to reduce exposure of extstore.h to the rest of memcached // but feels a little off being defined here. // At very least maybe "process_storage_stats" in line with making this more // of a generic wrapper module. void process_extstore_stats(ADD_STAT add_stats, conn *c) { int i; char key_str[STAT_KEY_LEN]; char val_str[STAT_VAL_LEN]; int klen = 0, vlen = 0; struct extstore_stats st; assert(add_stats); void *storage = c->thread->storage; if (storage == NULL) { return; } extstore_get_stats(storage, &st); st.page_data = calloc(st.page_count, sizeof(struct extstore_page_data)); extstore_get_page_data(storage, &st); for (i = 0; i < st.page_count; i++) { APPEND_NUM_STAT(i, "version", "%llu", (unsigned long long) st.page_data[i].version); APPEND_NUM_STAT(i, "bytes", "%llu", (unsigned long long) st.page_data[i].bytes_used); APPEND_NUM_STAT(i, "bucket", "%u", st.page_data[i].bucket); APPEND_NUM_STAT(i, "free_bucket", "%u", st.page_data[i].free_bucket); } } // Additional storage stats for the main stats output. void storage_stats(ADD_STAT add_stats, conn *c) { struct extstore_stats st; if (c->thread->storage) { STATS_LOCK(); APPEND_STAT("extstore_compact_lost", "%llu", (unsigned long long)stats.extstore_compact_lost); APPEND_STAT("extstore_compact_rescues", "%llu", (unsigned long long)stats.extstore_compact_rescues); APPEND_STAT("extstore_compact_skipped", "%llu", (unsigned long long)stats.extstore_compact_skipped); STATS_UNLOCK(); extstore_get_stats(c->thread->storage, &st); APPEND_STAT("extstore_page_allocs", "%llu", (unsigned long long)st.page_allocs); APPEND_STAT("extstore_page_evictions", "%llu", (unsigned long long)st.page_evictions); APPEND_STAT("extstore_page_reclaims", "%llu", (unsigned long long)st.page_reclaims); APPEND_STAT("extstore_pages_free", "%llu", (unsigned long long)st.pages_free); APPEND_STAT("extstore_pages_used", "%llu", (unsigned long long)st.pages_used); APPEND_STAT("extstore_objects_evicted", "%llu", (unsigned long long)st.objects_evicted); APPEND_STAT("extstore_objects_read", "%llu", (unsigned long long)st.objects_read); APPEND_STAT("extstore_objects_written", "%llu", (unsigned long long)st.objects_written); APPEND_STAT("extstore_objects_used", "%llu", (unsigned long long)st.objects_used); APPEND_STAT("extstore_bytes_evicted", "%llu", (unsigned long long)st.bytes_evicted); APPEND_STAT("extstore_bytes_written", "%llu", (unsigned long long)st.bytes_written); APPEND_STAT("extstore_bytes_read", "%llu", (unsigned long long)st.bytes_read); APPEND_STAT("extstore_bytes_used", "%llu", (unsigned long long)st.bytes_used); APPEND_STAT("extstore_bytes_fragmented", "%llu", (unsigned long long)st.bytes_fragmented); APPEND_STAT("extstore_limit_maxbytes", "%llu", (unsigned long long)(st.page_count * st.page_size)); APPEND_STAT("extstore_io_queue", "%llu", (unsigned long long)(st.io_queue)); } } // This callback runs in the IO thread. // TODO: Some or all of this should move to the // io_pending's callback back in the worker thread. // It might make sense to keep the crc32c check here though. static void _storage_get_item_cb(void *e, obj_io *io, int ret) { // FIXME: assumes success io_pending_storage_t *p = (io_pending_storage_t *)io->data; mc_resp *resp = p->resp; conn *c = p->c; assert(p->active == true); item *read_it = (item *)io->buf; bool miss = false; // TODO: How to do counters for hit/misses? if (ret < 1) { miss = true; } else { uint32_t crc2; uint32_t crc = (uint32_t) read_it->exptime; int x; // item is chunked, crc the iov's if (io->iov != NULL) { // first iov is the header, which we don't use beyond crc crc2 = crc32c(0, (char *)io->iov[0].iov_base+STORE_OFFSET, io->iov[0].iov_len-STORE_OFFSET); // make sure it's not sent. hack :( io->iov[0].iov_len = 0; for (x = 1; x < io->iovcnt; x++) { crc2 = crc32c(crc2, (char *)io->iov[x].iov_base, io->iov[x].iov_len); } } else { crc2 = crc32c(0, (char *)read_it+STORE_OFFSET, io->len-STORE_OFFSET); } if (crc != crc2) { miss = true; p->badcrc = true; } } if (miss) { if (p->noreply) { // In all GET cases, noreply means we send nothing back. resp->skip = true; } else { // TODO: This should be movable to the worker thread. // Convert the binprot response into a miss response. // The header requires knowing a bunch of stateful crap, so rather // than simply writing out a "new" miss response we mangle what's // already there. if (c->protocol == binary_prot) { protocol_binary_response_header *header = (protocol_binary_response_header *)resp->wbuf; // cut the extra nbytes off of the body_len uint32_t body_len = ntohl(header->response.bodylen); uint8_t hdr_len = header->response.extlen; body_len -= resp->iov[p->iovec_data].iov_len + hdr_len; resp->tosend -= resp->iov[p->iovec_data].iov_len + hdr_len; header->response.extlen = 0; header->response.status = (uint16_t)htons(PROTOCOL_BINARY_RESPONSE_KEY_ENOENT); header->response.bodylen = htonl(body_len); // truncate the data response. resp->iov[p->iovec_data].iov_len = 0; // wipe the extlen iov... wish it was just a flat buffer. resp->iov[p->iovec_data-1].iov_len = 0; resp->chunked_data_iov = 0; } else { int i; // Meta commands have EN status lines for miss, rather than // END as a trailer as per normal ascii. if (resp->iov[0].iov_len >= 3 && memcmp(resp->iov[0].iov_base, "VA ", 3) == 0) { // TODO: These miss translators should use specific callback // functions attached to the io wrap. This is weird :( resp->iovcnt = 1; resp->iov[0].iov_len = 4; resp->iov[0].iov_base = "EN\r\n"; resp->tosend = 4; } else { // Wipe the iovecs up through our data injection. // Allows trailers to be returned (END) for (i = 0; i <= p->iovec_data; i++) { resp->tosend -= resp->iov[i].iov_len; resp->iov[i].iov_len = 0; resp->iov[i].iov_base = NULL; } } resp->chunked_total = 0; resp->chunked_data_iov = 0; } } p->miss = true; } else { assert(read_it->slabs_clsid != 0); // TODO: should always use it instead of ITEM_data to kill more // chunked special casing. if ((read_it->it_flags & ITEM_CHUNKED) == 0) { resp->iov[p->iovec_data].iov_base = ITEM_data(read_it); } p->miss = false; } p->active = false; //assert(c->io_wrapleft >= 0); return_io_pending((io_pending_t *)p); } int storage_get_item(conn *c, item *it, mc_resp *resp) { #ifdef NEED_ALIGN item_hdr hdr; memcpy(&hdr, ITEM_data(it), sizeof(hdr)); #else item_hdr *hdr = (item_hdr *)ITEM_data(it); #endif io_queue_t *q = conn_io_queue_get(c, IO_QUEUE_EXTSTORE); size_t ntotal = ITEM_ntotal(it); unsigned int clsid = slabs_clsid(ntotal); item *new_it; bool chunked = false; if (ntotal > settings.slab_chunk_size_max) { // Pull a chunked item header. uint32_t flags; FLAGS_CONV(it, flags); new_it = item_alloc(ITEM_key(it), it->nkey, flags, it->exptime, it->nbytes); assert(new_it == NULL || (new_it->it_flags & ITEM_CHUNKED)); chunked = true; } else { new_it = do_item_alloc_pull(ntotal, clsid); } if (new_it == NULL) return -1; // so we can free the chunk on a miss new_it->slabs_clsid = clsid; io_pending_storage_t *p = do_cache_alloc(c->thread->io_cache); // this is a re-cast structure, so assert that we never outsize it. assert(sizeof(io_pending_t) >= sizeof(io_pending_storage_t)); memset(p, 0, sizeof(io_pending_storage_t)); p->active = true; p->miss = false; p->badcrc = false; p->noreply = c->noreply; p->thread = c->thread; p->return_cb = storage_return_cb; p->finalize_cb = storage_finalize_cb; // io_pending owns the reference for this object now. p->hdr_it = it; p->resp = resp; p->io_queue_type = IO_QUEUE_EXTSTORE; obj_io *eio = &p->io_ctx; // FIXME: error handling. if (chunked) { unsigned int ciovcnt = 0; size_t remain = new_it->nbytes; item_chunk *chunk = (item_chunk *) ITEM_schunk(new_it); // TODO: This might make sense as a _global_ cache vs a per-thread. // but we still can't load objects requiring > IOV_MAX iovs. // In the meantime, these objects are rare/slow enough that // malloc/freeing a statically sized object won't cause us much pain. eio->iov = malloc(sizeof(struct iovec) * IOV_MAX); if (eio->iov == NULL) { item_remove(new_it); do_cache_free(c->thread->io_cache, p); return -1; } // fill the header so we can get the full data + crc back. eio->iov[0].iov_base = new_it; eio->iov[0].iov_len = ITEM_ntotal(new_it) - new_it->nbytes; ciovcnt++; while (remain > 0) { chunk = do_item_alloc_chunk(chunk, remain); // FIXME: _pure evil_, silently erroring if item is too large. if (chunk == NULL || ciovcnt > IOV_MAX-1) { item_remove(new_it); free(eio->iov); // TODO: wrapper function for freeing up an io wrap? eio->iov = NULL; do_cache_free(c->thread->io_cache, p); return -1; } eio->iov[ciovcnt].iov_base = chunk->data; eio->iov[ciovcnt].iov_len = (remain < chunk->size) ? remain : chunk->size; chunk->used = (remain < chunk->size) ? remain : chunk->size; remain -= chunk->size; ciovcnt++; } eio->iovcnt = ciovcnt; } // Chunked or non chunked we reserve a response iov here. p->iovec_data = resp->iovcnt; int iovtotal = (c->protocol == binary_prot) ? it->nbytes - 2 : it->nbytes; if (chunked) { resp_add_chunked_iov(resp, new_it, iovtotal); } else { resp_add_iov(resp, "", iovtotal); } // We can't bail out anymore, so mc_resp owns the IO from here. resp->io_pending = (io_pending_t *)p; eio->buf = (void *)new_it; p->c = c; // We need to stack the sub-struct IO's together for submission. eio->next = q->stack_ctx; q->stack_ctx = eio; // No need to stack the io_pending's together as they live on mc_resp's. assert(q->count >= 0); q->count++; // reference ourselves for the callback. eio->data = (void *)p; // Now, fill in io->io based on what was in our header. #ifdef NEED_ALIGN eio->page_version = hdr.page_version; eio->page_id = hdr.page_id; eio->offset = hdr.offset; #else eio->page_version = hdr->page_version; eio->page_id = hdr->page_id; eio->offset = hdr->offset; #endif eio->len = ntotal; eio->mode = OBJ_IO_READ; eio->cb = _storage_get_item_cb; // FIXME: This stat needs to move to reflect # of flash hits vs misses // for now it's a good gauge on how often we request out to flash at // least. pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.get_extstore++; pthread_mutex_unlock(&c->thread->stats.mutex); return 0; } void storage_submit_cb(io_queue_t *q) { // Don't need to do anything special for extstore. extstore_submit(q->ctx, q->stack_ctx); // need to reset the stack for next use. q->stack_ctx = NULL; } // Runs locally in worker thread. static void recache_or_free(io_pending_t *pending) { // re-cast to our specific struct. io_pending_storage_t *p = (io_pending_storage_t *)pending; conn *c = p->c; obj_io *io = &p->io_ctx; assert(io != NULL); item *it = (item *)io->buf; assert(c != NULL); bool do_free = true; if (p->active) { // If request never dispatched, free the read buffer but leave the // item header alone. do_free = false; size_t ntotal = ITEM_ntotal(p->hdr_it); slabs_free(it, ntotal, slabs_clsid(ntotal)); io_queue_t *q = conn_io_queue_get(c, p->io_queue_type); q->count--; assert(q->count >= 0); pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.get_aborted_extstore++; pthread_mutex_unlock(&c->thread->stats.mutex); } else if (p->miss) { // If request was ultimately a miss, unlink the header. do_free = false; size_t ntotal = ITEM_ntotal(p->hdr_it); item_unlink(p->hdr_it); slabs_free(it, ntotal, slabs_clsid(ntotal)); pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.miss_from_extstore++; if (p->badcrc) c->thread->stats.badcrc_from_extstore++; pthread_mutex_unlock(&c->thread->stats.mutex); } else if (settings.ext_recache_rate) { // hashvalue is cuddled during store uint32_t hv = (uint32_t)it->time; // opt to throw away rather than wait on a lock. void *hold_lock = item_trylock(hv); if (hold_lock != NULL) { item *h_it = p->hdr_it; uint8_t flags = ITEM_LINKED|ITEM_FETCHED|ITEM_ACTIVE; // Item must be recently hit at least twice to recache. if (((h_it->it_flags & flags) == flags) && h_it->time > current_time - ITEM_UPDATE_INTERVAL && c->recache_counter++ % settings.ext_recache_rate == 0) { do_free = false; // In case it's been updated. it->exptime = h_it->exptime; it->it_flags &= ~ITEM_LINKED; it->refcount = 0; it->h_next = NULL; // might not be necessary. STORAGE_delete(c->thread->storage, h_it); item_replace(h_it, it, hv); pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.recache_from_extstore++; pthread_mutex_unlock(&c->thread->stats.mutex); } } if (hold_lock) item_trylock_unlock(hold_lock); } if (do_free) slabs_free(it, ITEM_ntotal(it), ITEM_clsid(it)); p->io_ctx.buf = NULL; p->io_ctx.next = NULL; p->active = false; // TODO: reuse lock and/or hv. item_remove(p->hdr_it); } // Called after an IO has been returned to the worker thread. static void storage_return_cb(io_pending_t *pending) { io_queue_t *q = conn_io_queue_get(pending->c, pending->io_queue_type); q->count--; if (q->count == 0) { conn_worker_readd(pending->c); } } // Called after responses have been transmitted. Need to free up related data. static void storage_finalize_cb(io_pending_t *pending) { recache_or_free(pending); io_pending_storage_t *p = (io_pending_storage_t *)pending; obj_io *io = &p->io_ctx; // malloc'ed iovec list used for chunked extstore fetches. if (io->iov) { free(io->iov); io->iov = NULL; } // don't need to free the main context, since it's embedded. } /* * WRITE FLUSH THREAD */ static int storage_write(void *storage, const int clsid, const int item_age) { int did_moves = 0; struct lru_pull_tail_return it_info; it_info.it = NULL; lru_pull_tail(clsid, COLD_LRU, 0, LRU_PULL_RETURN_ITEM, 0, &it_info); /* Item is locked, and we have a reference to it. */ if (it_info.it == NULL) { return did_moves; } obj_io io; item *it = it_info.it; /* First, storage for the header object */ size_t orig_ntotal = ITEM_ntotal(it); uint32_t flags; if ((it->it_flags & ITEM_HDR) == 0 && (item_age == 0 || current_time - it->time > item_age)) { FLAGS_CONV(it, flags); item *hdr_it = do_item_alloc(ITEM_key(it), it->nkey, flags, it->exptime, sizeof(item_hdr)); /* Run the storage write understanding the start of the item is dirty. * We will fill it (time/exptime/etc) from the header item on read. */ if (hdr_it != NULL) { int bucket = (it->it_flags & ITEM_CHUNKED) ? PAGE_BUCKET_CHUNKED : PAGE_BUCKET_DEFAULT; // Compress soon to expire items into similar pages. if (it->exptime - current_time < settings.ext_low_ttl) { bucket = PAGE_BUCKET_LOWTTL; } hdr_it->it_flags |= ITEM_HDR; io.len = orig_ntotal; io.mode = OBJ_IO_WRITE; // NOTE: when the item is read back in, the slab mover // may see it. Important to have refcount>=2 or ~ITEM_LINKED assert(it->refcount >= 2); // NOTE: write bucket vs free page bucket will disambiguate once // lowttl feature is better understood. if (extstore_write_request(storage, bucket, bucket, &io) == 0) { // cuddle the hash value into the time field so we don't have // to recalculate it. item *buf_it = (item *) io.buf; buf_it->time = it_info.hv; // copy from past the headers + time headers. // TODO: should be in items.c if (it->it_flags & ITEM_CHUNKED) { // Need to loop through the item and copy item_chunk *sch = (item_chunk *) ITEM_schunk(it); int remain = orig_ntotal; int copied = 0; // copy original header int hdrtotal = ITEM_ntotal(it) - it->nbytes; memcpy((char *)io.buf+STORE_OFFSET, (char *)it+STORE_OFFSET, hdrtotal - STORE_OFFSET); copied = hdrtotal; // copy data in like it were one large object. while (sch && remain) { assert(remain >= sch->used); memcpy((char *)io.buf+copied, sch->data, sch->used); // FIXME: use one variable? remain -= sch->used; copied += sch->used; sch = sch->next; } } else { memcpy((char *)io.buf+STORE_OFFSET, (char *)it+STORE_OFFSET, io.len-STORE_OFFSET); } // crc what we copied so we can do it sequentially. buf_it->it_flags &= ~ITEM_LINKED; buf_it->exptime = crc32c(0, (char*)io.buf+STORE_OFFSET, orig_ntotal-STORE_OFFSET); extstore_write(storage, &io); item_hdr *hdr = (item_hdr *) ITEM_data(hdr_it); hdr->page_version = io.page_version; hdr->page_id = io.page_id; hdr->offset = io.offset; // overload nbytes for the header it hdr_it->nbytes = it->nbytes; /* success! Now we need to fill relevant data into the new * header and replace. Most of this requires the item lock */ /* CAS gets set while linking. Copy post-replace */ item_replace(it, hdr_it, it_info.hv); ITEM_set_cas(hdr_it, ITEM_get_cas(it)); do_item_remove(hdr_it); did_moves = 1; LOGGER_LOG(NULL, LOG_EVICTIONS, LOGGER_EXTSTORE_WRITE, it, bucket); } else { /* Failed to write for some reason, can't continue. */ slabs_free(hdr_it, ITEM_ntotal(hdr_it), ITEM_clsid(hdr_it)); } } } do_item_remove(it); item_unlock(it_info.hv); return did_moves; } static pthread_t storage_write_tid; static pthread_mutex_t storage_write_plock; #define WRITE_SLEEP_MIN 200 static void *storage_write_thread(void *arg) { void *storage = arg; // NOTE: ignoring overflow since that would take years of uptime in a // specific load pattern of never going to sleep. unsigned int backoff[MAX_NUMBER_OF_SLAB_CLASSES] = {0}; unsigned int counter = 0; useconds_t to_sleep = WRITE_SLEEP_MIN; logger *l = logger_create(); if (l == NULL) { fprintf(stderr, "Failed to allocate logger for storage compaction thread\n"); abort(); } pthread_mutex_lock(&storage_write_plock); while (1) { // cache per-loop to avoid calls to the slabs_clsid() search loop int min_class = slabs_clsid(settings.ext_item_size); unsigned int global_pages = global_page_pool_size(NULL); bool do_sleep = true; int target_pages = 0; if (global_pages < settings.ext_global_pool_min) { target_pages = settings.ext_global_pool_min - global_pages; } counter++; if (to_sleep > settings.ext_max_sleep) to_sleep = settings.ext_max_sleep; for (int x = 0; x < MAX_NUMBER_OF_SLAB_CLASSES; x++) { bool did_move = false; bool mem_limit_reached = false; unsigned int chunks_free; int item_age; if (min_class > x || (backoff[x] && (counter % backoff[x] != 0))) { continue; } // Avoid extra slab lock calls during heavy writing. unsigned int chunks_perpage = 0; chunks_free = slabs_available_chunks(x, &mem_limit_reached, &chunks_perpage); unsigned int target = chunks_perpage * target_pages; // storage_write() will fail and cut loop after filling write buffer. while (1) { // if we are low on chunks and no spare, push out early. if (chunks_free < target) { item_age = 0; } else { item_age = settings.ext_item_age; } if (storage_write(storage, x, item_age)) { chunks_free++; // Allow stopping if we've done enough this loop did_move = true; do_sleep = false; if (to_sleep > WRITE_SLEEP_MIN) to_sleep /= 2; } else { break; } } if (!did_move) { backoff[x]++; } else { backoff[x] = 1; } } // flip lock so we can be paused or stopped pthread_mutex_unlock(&storage_write_plock); if (do_sleep) { // Only do backoffs on other slab classes if we're actively // flushing at least one class. for (int x = 0; x < MAX_NUMBER_OF_SLAB_CLASSES; x++) { backoff[x] = 1; } usleep(to_sleep); to_sleep++; } pthread_mutex_lock(&storage_write_plock); } return NULL; } // TODO // logger needs logger_destroy() to exist/work before this is safe. /*int stop_storage_write_thread(void) { int ret; pthread_mutex_lock(&lru_maintainer_lock); do_run_lru_maintainer_thread = 0; pthread_mutex_unlock(&lru_maintainer_lock); // WAKEUP SIGNAL if ((ret = pthread_join(lru_maintainer_tid, NULL)) != 0) { fprintf(stderr, "Failed to stop LRU maintainer thread: %s\n", strerror(ret)); return -1; } settings.lru_maintainer_thread = false; return 0; }*/ void storage_write_pause(void) { pthread_mutex_lock(&storage_write_plock); } void storage_write_resume(void) { pthread_mutex_unlock(&storage_write_plock); } int start_storage_write_thread(void *arg) { int ret; pthread_mutex_init(&storage_write_plock, NULL); if ((ret = pthread_create(&storage_write_tid, NULL, storage_write_thread, arg)) != 0) { fprintf(stderr, "Can't create storage_write thread: %s\n", strerror(ret)); return -1; } thread_setname(storage_write_tid, "mc-ext-write"); return 0; } /*** COMPACTOR ***/ /* Fetch stats from the external storage system and decide to compact. * If we're more than half full, start skewing how aggressively to run * compaction, up to a desired target when all pages are full. */ static int storage_compact_check(void *storage, logger *l, uint32_t *page_id, uint64_t *page_version, uint64_t *page_size, bool *drop_unread) { struct extstore_stats st; int x; double rate; uint64_t frag_limit; uint64_t low_version = ULLONG_MAX; uint64_t lowest_version = ULLONG_MAX; unsigned int low_page = 0; unsigned int lowest_page = 0; extstore_get_stats(storage, &st); if (st.pages_used == 0) return 0; // lets pick a target "wasted" value and slew. if (st.pages_free > settings.ext_compact_under) return 0; *drop_unread = false; // the number of free pages reduces the configured frag limit // this allows us to defrag early if pages are very empty. rate = 1.0 - ((double)st.pages_free / st.page_count); rate *= settings.ext_max_frag; frag_limit = st.page_size * rate; LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_COMPACT_FRAGINFO, NULL, rate, frag_limit); st.page_data = calloc(st.page_count, sizeof(struct extstore_page_data)); extstore_get_page_data(storage, &st); // find oldest page by version that violates the constraint for (x = 0; x < st.page_count; x++) { if (st.page_data[x].version == 0 || st.page_data[x].bucket == PAGE_BUCKET_LOWTTL) continue; if (st.page_data[x].version < lowest_version) { lowest_page = x; lowest_version = st.page_data[x].version; } if (st.page_data[x].bytes_used < frag_limit) { if (st.page_data[x].version < low_version) { low_page = x; low_version = st.page_data[x].version; } } } *page_size = st.page_size; free(st.page_data); // we have a page + version to attempt to reclaim. if (low_version != ULLONG_MAX) { *page_id = low_page; *page_version = low_version; return 1; } else if (lowest_version != ULLONG_MAX && settings.ext_drop_unread && st.pages_free <= settings.ext_drop_under) { // nothing matched the frag rate barrier, so pick the absolute oldest // version if we're configured to drop items. *page_id = lowest_page; *page_version = lowest_version; *drop_unread = true; return 1; } return 0; } static pthread_t storage_compact_tid; static pthread_mutex_t storage_compact_plock; #define MIN_STORAGE_COMPACT_SLEEP 10000 struct storage_compact_wrap { obj_io io; pthread_mutex_t lock; // gates the bools. bool done; bool submitted; bool miss; // version flipped out from under us }; static void storage_compact_readback(void *storage, logger *l, bool drop_unread, char *readback_buf, uint32_t page_id, uint64_t page_version, uint64_t read_size) { uint64_t offset = 0; unsigned int rescues = 0; unsigned int lost = 0; unsigned int skipped = 0; while (offset < read_size) { item *hdr_it = NULL; item_hdr *hdr = NULL; item *it = (item *)(readback_buf+offset); unsigned int ntotal; // probably zeroed out junk at the end of the wbuf if (it->nkey == 0) { break; } ntotal = ITEM_ntotal(it); uint32_t hv = (uint32_t)it->time; item_lock(hv); // We don't have a conn and don't need to do most of do_item_get hdr_it = assoc_find(ITEM_key(it), it->nkey, hv); if (hdr_it != NULL) { bool do_write = false; refcount_incr(hdr_it); // Check validity but don't bother removing it. if ((hdr_it->it_flags & ITEM_HDR) && !item_is_flushed(hdr_it) && (hdr_it->exptime == 0 || hdr_it->exptime > current_time)) { hdr = (item_hdr *)ITEM_data(hdr_it); if (hdr->page_id == page_id && hdr->page_version == page_version) { // Item header is still completely valid. extstore_delete(storage, page_id, page_version, 1, ntotal); // drop inactive items. if (drop_unread && GET_LRU(hdr_it->slabs_clsid) == COLD_LRU) { do_write = false; skipped++; } else { do_write = true; } } } if (do_write) { bool do_update = false; int tries; obj_io io; io.len = ntotal; io.mode = OBJ_IO_WRITE; for (tries = 10; tries > 0; tries--) { if (extstore_write_request(storage, PAGE_BUCKET_COMPACT, PAGE_BUCKET_COMPACT, &io) == 0) { memcpy(io.buf, it, io.len); extstore_write(storage, &io); do_update = true; break; } else { usleep(1000); } } if (do_update) { if (it->refcount == 2) { hdr->page_version = io.page_version; hdr->page_id = io.page_id; hdr->offset = io.offset; rescues++; } else { lost++; // TODO: re-alloc and replace header. } } else { lost++; } } do_item_remove(hdr_it); } item_unlock(hv); offset += ntotal; if (read_size - offset < sizeof(struct _stritem)) break; } STATS_LOCK(); stats.extstore_compact_lost += lost; stats.extstore_compact_rescues += rescues; stats.extstore_compact_skipped += skipped; STATS_UNLOCK(); LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_COMPACT_READ_END, NULL, page_id, offset, rescues, lost, skipped); } static void _storage_compact_cb(void *e, obj_io *io, int ret) { struct storage_compact_wrap *wrap = (struct storage_compact_wrap *)io->data; assert(wrap->submitted == true); pthread_mutex_lock(&wrap->lock); if (ret < 1) { wrap->miss = true; } wrap->done = true; pthread_mutex_unlock(&wrap->lock); } // TODO: hoist the storage bits from lru_maintainer_thread in here. // would be nice if they could avoid hammering the same locks though? // I guess it's only COLD. that's probably fine. static void *storage_compact_thread(void *arg) { void *storage = arg; useconds_t to_sleep = settings.ext_max_sleep; bool compacting = false; uint64_t page_version = 0; uint64_t page_size = 0; uint64_t page_offset = 0; uint32_t page_id = 0; bool drop_unread = false; char *readback_buf = NULL; struct storage_compact_wrap wrap; logger *l = logger_create(); if (l == NULL) { fprintf(stderr, "Failed to allocate logger for storage compaction thread\n"); abort(); } readback_buf = malloc(settings.ext_wbuf_size); if (readback_buf == NULL) { fprintf(stderr, "Failed to allocate readback buffer for storage compaction thread\n"); abort(); } pthread_mutex_init(&wrap.lock, NULL); wrap.done = false; wrap.submitted = false; wrap.io.data = &wrap; wrap.io.iov = NULL; wrap.io.buf = (void *)readback_buf; wrap.io.len = settings.ext_wbuf_size; wrap.io.mode = OBJ_IO_READ; wrap.io.cb = _storage_compact_cb; pthread_mutex_lock(&storage_compact_plock); while (1) { pthread_mutex_unlock(&storage_compact_plock); if (to_sleep) { extstore_run_maint(storage); usleep(to_sleep); } pthread_mutex_lock(&storage_compact_plock); if (!compacting && storage_compact_check(storage, l, &page_id, &page_version, &page_size, &drop_unread)) { page_offset = 0; compacting = true; LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_COMPACT_START, NULL, page_id, page_version); } if (compacting) { pthread_mutex_lock(&wrap.lock); if (page_offset < page_size && !wrap.done && !wrap.submitted) { wrap.io.page_version = page_version; wrap.io.page_id = page_id; wrap.io.offset = page_offset; // FIXME: should be smarter about io->next (unlink at use?) wrap.io.next = NULL; wrap.submitted = true; wrap.miss = false; extstore_submit(storage, &wrap.io); } else if (wrap.miss) { LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_COMPACT_ABORT, NULL, page_id); wrap.done = false; wrap.submitted = false; compacting = false; } else if (wrap.submitted && wrap.done) { LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_COMPACT_READ_START, NULL, page_id, page_offset); storage_compact_readback(storage, l, drop_unread, readback_buf, page_id, page_version, settings.ext_wbuf_size); page_offset += settings.ext_wbuf_size; wrap.done = false; wrap.submitted = false; } else if (page_offset >= page_size) { compacting = false; wrap.done = false; wrap.submitted = false; extstore_close_page(storage, page_id, page_version); LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_COMPACT_END, NULL, page_id); } pthread_mutex_unlock(&wrap.lock); // finish actual compaction quickly. to_sleep = MIN_STORAGE_COMPACT_SLEEP; } else { if (to_sleep < settings.ext_max_sleep) to_sleep += settings.ext_max_sleep; } } free(readback_buf); return NULL; } // TODO // logger needs logger_destroy() to exist/work before this is safe. /*int stop_storage_compact_thread(void) { int ret; pthread_mutex_lock(&lru_maintainer_lock); do_run_lru_maintainer_thread = 0; pthread_mutex_unlock(&lru_maintainer_lock); if ((ret = pthread_join(lru_maintainer_tid, NULL)) != 0) { fprintf(stderr, "Failed to stop LRU maintainer thread: %s\n", strerror(ret)); return -1; } settings.lru_maintainer_thread = false; return 0; }*/ void storage_compact_pause(void) { pthread_mutex_lock(&storage_compact_plock); } void storage_compact_resume(void) { pthread_mutex_unlock(&storage_compact_plock); } int start_storage_compact_thread(void *arg) { int ret; pthread_mutex_init(&storage_compact_plock, NULL); if ((ret = pthread_create(&storage_compact_tid, NULL, storage_compact_thread, arg)) != 0) { fprintf(stderr, "Can't create storage_compact thread: %s\n", strerror(ret)); return -1; } thread_setname(storage_compact_tid, "mc-ext-compact"); return 0; } /*** UTILITY ***/ // /path/to/file:100G:bucket1 // FIXME: Modifies argument. copy instead? struct extstore_conf_file *storage_conf_parse(char *arg, unsigned int page_size) { struct extstore_conf_file *cf = NULL; char *b = NULL; char *p = strtok_r(arg, ":", &b); char unit = 0; uint64_t multiplier = 0; int base_size = 0; if (p == NULL) goto error; // First arg is the filepath. cf = calloc(1, sizeof(struct extstore_conf_file)); cf->file = strdup(p); p = strtok_r(NULL, ":", &b); if (p == NULL) { fprintf(stderr, "must supply size to ext_path, ie: ext_path=/f/e:64m (M|G|T|P supported)\n"); goto error; } unit = tolower(p[strlen(p)-1]); p[strlen(p)-1] = '\0'; // sigh. switch (unit) { case 'm': multiplier = 1024 * 1024; break; case 'g': multiplier = 1024 * 1024 * 1024; break; case 't': multiplier = 1024 * 1024; multiplier *= 1024 * 1024; break; case 'p': multiplier = 1024 * 1024; multiplier *= 1024 * 1024 * 1024; break; } base_size = atoi(p); multiplier *= base_size; // page_count is nearest-but-not-larger-than pages * psize cf->page_count = multiplier / page_size; assert(page_size * cf->page_count <= multiplier); // final token would be a default free bucket p = strtok_r(NULL, ",", &b); // TODO: We reuse the original DEFINES for now, // but if lowttl gets split up this needs to be its own set. if (p != NULL) { if (strcmp(p, "compact") == 0) { cf->free_bucket = PAGE_BUCKET_COMPACT; } else if (strcmp(p, "lowttl") == 0) { cf->free_bucket = PAGE_BUCKET_LOWTTL; } else if (strcmp(p, "chunked") == 0) { cf->free_bucket = PAGE_BUCKET_CHUNKED; } else if (strcmp(p, "default") == 0) { cf->free_bucket = PAGE_BUCKET_DEFAULT; } else { fprintf(stderr, "Unknown extstore bucket: %s\n", p); goto error; } } else { // TODO: is this necessary? cf->free_bucket = PAGE_BUCKET_DEFAULT; } // TODO: disabling until compact algorithm is improved. if (cf->free_bucket != PAGE_BUCKET_DEFAULT) { fprintf(stderr, "ext_path only presently supports the default bucket\n"); goto error; } return cf; error: if (cf) { if (cf->file) free(cf->file); free(cf); } return NULL; } struct storage_settings { struct extstore_conf_file *storage_file; struct extstore_conf ext_cf; }; void *storage_init_config(struct settings *s) { struct storage_settings *cf = calloc(1, sizeof(struct storage_settings)); s->ext_item_size = 512; s->ext_item_age = UINT_MAX; s->ext_low_ttl = 0; s->ext_recache_rate = 2000; s->ext_max_frag = 0.8; s->ext_drop_unread = false; s->ext_wbuf_size = 1024 * 1024 * 4; s->ext_compact_under = 0; s->ext_drop_under = 0; s->ext_max_sleep = 1000000; s->slab_automove_freeratio = 0.01; s->ext_page_size = 1024 * 1024 * 64; s->ext_io_threadcount = 1; cf->ext_cf.page_size = settings.ext_page_size; cf->ext_cf.wbuf_size = settings.ext_wbuf_size; cf->ext_cf.io_threadcount = settings.ext_io_threadcount; cf->ext_cf.io_depth = 1; cf->ext_cf.page_buckets = 4; cf->ext_cf.wbuf_count = cf->ext_cf.page_buckets; return cf; } // TODO: pass settings struct? int storage_read_config(void *conf, char **subopt) { struct storage_settings *cf = conf; struct extstore_conf *ext_cf = &cf->ext_cf; char *subopts_value; enum { EXT_PAGE_SIZE, EXT_WBUF_SIZE, EXT_THREADS, EXT_IO_DEPTH, EXT_PATH, EXT_ITEM_SIZE, EXT_ITEM_AGE, EXT_LOW_TTL, EXT_RECACHE_RATE, EXT_COMPACT_UNDER, EXT_DROP_UNDER, EXT_MAX_SLEEP, EXT_MAX_FRAG, EXT_DROP_UNREAD, SLAB_AUTOMOVE_FREERATIO, // FIXME: move this back? }; char *const subopts_tokens[] = { [EXT_PAGE_SIZE] = "ext_page_size", [EXT_WBUF_SIZE] = "ext_wbuf_size", [EXT_THREADS] = "ext_threads", [EXT_IO_DEPTH] = "ext_io_depth", [EXT_PATH] = "ext_path", [EXT_ITEM_SIZE] = "ext_item_size", [EXT_ITEM_AGE] = "ext_item_age", [EXT_LOW_TTL] = "ext_low_ttl", [EXT_RECACHE_RATE] = "ext_recache_rate", [EXT_COMPACT_UNDER] = "ext_compact_under", [EXT_DROP_UNDER] = "ext_drop_under", [EXT_MAX_SLEEP] = "ext_max_sleep", [EXT_MAX_FRAG] = "ext_max_frag", [EXT_DROP_UNREAD] = "ext_drop_unread", [SLAB_AUTOMOVE_FREERATIO] = "slab_automove_freeratio", NULL }; switch (getsubopt(subopt, subopts_tokens, &subopts_value)) { case EXT_PAGE_SIZE: if (cf->storage_file) { fprintf(stderr, "Must specify ext_page_size before any ext_path arguments\n"); return 1; } if (subopts_value == NULL) { fprintf(stderr, "Missing ext_page_size argument\n"); return 1; } if (!safe_strtoul(subopts_value, &ext_cf->page_size)) { fprintf(stderr, "could not parse argument to ext_page_size\n"); return 1; } ext_cf->page_size *= 1024 * 1024; /* megabytes */ break; case EXT_WBUF_SIZE: if (subopts_value == NULL) { fprintf(stderr, "Missing ext_wbuf_size argument\n"); return 1; } if (!safe_strtoul(subopts_value, &ext_cf->wbuf_size)) { fprintf(stderr, "could not parse argument to ext_wbuf_size\n"); return 1; } ext_cf->wbuf_size *= 1024 * 1024; /* megabytes */ settings.ext_wbuf_size = ext_cf->wbuf_size; break; case EXT_THREADS: if (subopts_value == NULL) { fprintf(stderr, "Missing ext_threads argument\n"); return 1; } if (!safe_strtoul(subopts_value, &ext_cf->io_threadcount)) { fprintf(stderr, "could not parse argument to ext_threads\n"); return 1; } break; case EXT_IO_DEPTH: if (subopts_value == NULL) { fprintf(stderr, "Missing ext_io_depth argument\n"); return 1; } if (!safe_strtoul(subopts_value, &ext_cf->io_depth)) { fprintf(stderr, "could not parse argument to ext_io_depth\n"); return 1; } break; case EXT_ITEM_SIZE: if (subopts_value == NULL) { fprintf(stderr, "Missing ext_item_size argument\n"); return 1; } if (!safe_strtoul(subopts_value, &settings.ext_item_size)) { fprintf(stderr, "could not parse argument to ext_item_size\n"); return 1; } break; case EXT_ITEM_AGE: if (subopts_value == NULL) { fprintf(stderr, "Missing ext_item_age argument\n"); return 1; } if (!safe_strtoul(subopts_value, &settings.ext_item_age)) { fprintf(stderr, "could not parse argument to ext_item_age\n"); return 1; } break; case EXT_LOW_TTL: if (subopts_value == NULL) { fprintf(stderr, "Missing ext_low_ttl argument\n"); return 1; } if (!safe_strtoul(subopts_value, &settings.ext_low_ttl)) { fprintf(stderr, "could not parse argument to ext_low_ttl\n"); return 1; } break; case EXT_RECACHE_RATE: if (subopts_value == NULL) { fprintf(stderr, "Missing ext_recache_rate argument\n"); return 1; } if (!safe_strtoul(subopts_value, &settings.ext_recache_rate)) { fprintf(stderr, "could not parse argument to ext_recache_rate\n"); return 1; } break; case EXT_COMPACT_UNDER: if (subopts_value == NULL) { fprintf(stderr, "Missing ext_compact_under argument\n"); return 1; } if (!safe_strtoul(subopts_value, &settings.ext_compact_under)) { fprintf(stderr, "could not parse argument to ext_compact_under\n"); return 1; } break; case EXT_DROP_UNDER: if (subopts_value == NULL) { fprintf(stderr, "Missing ext_drop_under argument\n"); return 1; } if (!safe_strtoul(subopts_value, &settings.ext_drop_under)) { fprintf(stderr, "could not parse argument to ext_drop_under\n"); return 1; } break; case EXT_MAX_SLEEP: if (subopts_value == NULL) { fprintf(stderr, "Missing ext_max_sleep argument\n"); return 1; } if (!safe_strtoul(subopts_value, &settings.ext_max_sleep)) { fprintf(stderr, "could not parse argument to ext_max_sleep\n"); return 1; } break; case EXT_MAX_FRAG: if (subopts_value == NULL) { fprintf(stderr, "Missing ext_max_frag argument\n"); return 1; } if (!safe_strtod(subopts_value, &settings.ext_max_frag)) { fprintf(stderr, "could not parse argument to ext_max_frag\n"); return 1; } break; case SLAB_AUTOMOVE_FREERATIO: if (subopts_value == NULL) { fprintf(stderr, "Missing slab_automove_freeratio argument\n"); return 1; } if (!safe_strtod(subopts_value, &settings.slab_automove_freeratio)) { fprintf(stderr, "could not parse argument to slab_automove_freeratio\n"); return 1; } break; case EXT_DROP_UNREAD: settings.ext_drop_unread = true; break; case EXT_PATH: if (subopts_value) { struct extstore_conf_file *tmp = storage_conf_parse(subopts_value, ext_cf->page_size); if (tmp == NULL) { fprintf(stderr, "failed to parse ext_path argument\n"); return 1; } if (cf->storage_file != NULL) { tmp->next = cf->storage_file; } cf->storage_file = tmp; } else { fprintf(stderr, "missing argument to ext_path, ie: ext_path=/d/file:5G\n"); return 1; } break; default: fprintf(stderr, "Illegal suboption \"%s\"\n", subopts_value); return 1; } return 0; } int storage_check_config(void *conf) { struct storage_settings *cf = conf; struct extstore_conf *ext_cf = &cf->ext_cf; if (cf->storage_file) { if (settings.item_size_max > ext_cf->wbuf_size) { fprintf(stderr, "-I (item_size_max: %d) cannot be larger than ext_wbuf_size: %d\n", settings.item_size_max, ext_cf->wbuf_size); return 1; } if (settings.udpport) { fprintf(stderr, "Cannot use UDP with extstore enabled (-U 0 to disable)\n"); return 1; } return 0; } return 2; } void *storage_init(void *conf) { struct storage_settings *cf = conf; struct extstore_conf *ext_cf = &cf->ext_cf; enum extstore_res eres; void *storage = NULL; if (settings.ext_compact_under == 0) { // If changing the default fraction (4), change the help text as well. settings.ext_compact_under = cf->storage_file->page_count / 4; /* Only rescues non-COLD items if below this threshold */ settings.ext_drop_under = cf->storage_file->page_count / 4; } crc32c_init(); settings.ext_global_pool_min = 0; storage = extstore_init(cf->storage_file, ext_cf, &eres); if (storage == NULL) { fprintf(stderr, "Failed to initialize external storage: %s\n", extstore_err(eres)); if (eres == EXTSTORE_INIT_OPEN_FAIL) { perror("extstore open"); } return NULL; } return storage; } #endif memcached-1.6.20/thread.c0000664000175000017500000007770014427543277012076 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ /* * Thread management for memcached. */ #include "memcached.h" #ifdef EXTSTORE #include "storage.h" #endif #ifdef HAVE_EVENTFD #include #endif #ifdef PROXY #include "proto_proxy.h" #endif #include #include #include #include #include #include #include "queue.h" #ifdef __sun #include #endif #ifdef TLS #include #endif #define ITEMS_PER_ALLOC 64 /* An item in the connection queue. */ enum conn_queue_item_modes { queue_new_conn, /* brand new connection. */ queue_pause, /* pause thread */ queue_timeout, /* socket sfd timed out */ queue_redispatch, /* return conn from side thread */ queue_stop, /* exit thread */ queue_return_io, /* returning a pending IO object immediately */ #ifdef PROXY queue_proxy_reload, /* signal proxy to reload worker VM */ #endif }; typedef struct conn_queue_item CQ_ITEM; struct conn_queue_item { int sfd; enum conn_states init_state; int event_flags; int read_buffer_size; enum network_transport transport; enum conn_queue_item_modes mode; conn *c; void *ssl; uint64_t conntag; enum protocol bproto; io_pending_t *io; // IO when used for deferred IO handling. STAILQ_ENTRY(conn_queue_item) i_next; }; /* A connection queue. */ typedef struct conn_queue CQ; struct conn_queue { STAILQ_HEAD(conn_ev_head, conn_queue_item) head; pthread_mutex_t lock; cache_t *cache; /* freelisted objects */ }; /* Locks for cache LRU operations */ pthread_mutex_t lru_locks[POWER_LARGEST]; /* Connection lock around accepting new connections */ pthread_mutex_t conn_lock = PTHREAD_MUTEX_INITIALIZER; #if !defined(HAVE_GCC_ATOMICS) && !defined(__sun) pthread_mutex_t atomics_mutex = PTHREAD_MUTEX_INITIALIZER; #endif /* Lock for global stats */ static pthread_mutex_t stats_lock = PTHREAD_MUTEX_INITIALIZER; /* Lock to cause worker threads to hang up after being woken */ static pthread_mutex_t worker_hang_lock; static pthread_mutex_t *item_locks; /* size of the item lock hash table */ static uint32_t item_lock_count; static unsigned int item_lock_hashpower; #define hashsize(n) ((unsigned long int)1<<(n)) #define hashmask(n) (hashsize(n)-1) /* * Each libevent instance has a wakeup pipe, which other threads * can use to signal that they've put a new connection on its queue. */ static LIBEVENT_THREAD *threads; /* * Number of worker threads that have finished setting themselves up. */ static int init_count = 0; static pthread_mutex_t init_lock; static pthread_cond_t init_cond; static void notify_worker(LIBEVENT_THREAD *t, CQ_ITEM *item); static void notify_worker_fd(LIBEVENT_THREAD *t, int sfd, enum conn_queue_item_modes mode); static CQ_ITEM *cqi_new(CQ *cq); static void cq_push(CQ *cq, CQ_ITEM *item); static void thread_libevent_process(evutil_socket_t fd, short which, void *arg); /* item_lock() must be held for an item before any modifications to either its * associated hash bucket, or the structure itself. * LRU modifications must hold the item lock, and the LRU lock. * LRU's accessing items must item_trylock() before modifying an item. * Items accessible from an LRU must not be freed or modified * without first locking and removing from the LRU. */ void item_lock(uint32_t hv) { mutex_lock(&item_locks[hv & hashmask(item_lock_hashpower)]); } void *item_trylock(uint32_t hv) { pthread_mutex_t *lock = &item_locks[hv & hashmask(item_lock_hashpower)]; if (pthread_mutex_trylock(lock) == 0) { return lock; } return NULL; } void item_trylock_unlock(void *lock) { mutex_unlock((pthread_mutex_t *) lock); } void item_unlock(uint32_t hv) { mutex_unlock(&item_locks[hv & hashmask(item_lock_hashpower)]); } static void wait_for_thread_registration(int nthreads) { while (init_count < nthreads) { pthread_cond_wait(&init_cond, &init_lock); } } static void register_thread_initialized(void) { pthread_mutex_lock(&init_lock); init_count++; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock); /* Force worker threads to pile up if someone wants us to */ pthread_mutex_lock(&worker_hang_lock); pthread_mutex_unlock(&worker_hang_lock); } /* Must not be called with any deeper locks held */ void pause_threads(enum pause_thread_types type) { int i; bool pause_workers = false; switch (type) { case PAUSE_ALL_THREADS: slabs_rebalancer_pause(); lru_maintainer_pause(); lru_crawler_pause(); #ifdef EXTSTORE storage_compact_pause(); storage_write_pause(); #endif case PAUSE_WORKER_THREADS: pause_workers = true; pthread_mutex_lock(&worker_hang_lock); break; case RESUME_ALL_THREADS: slabs_rebalancer_resume(); lru_maintainer_resume(); lru_crawler_resume(); #ifdef EXTSTORE storage_compact_resume(); storage_write_resume(); #endif case RESUME_WORKER_THREADS: pthread_mutex_unlock(&worker_hang_lock); break; default: fprintf(stderr, "Unknown lock type: %d\n", type); assert(1 == 0); break; } /* Only send a message if we have one. */ if (!pause_workers) { return; } pthread_mutex_lock(&init_lock); init_count = 0; for (i = 0; i < settings.num_threads; i++) { notify_worker_fd(&threads[i], 0, queue_pause); } wait_for_thread_registration(settings.num_threads); pthread_mutex_unlock(&init_lock); } // MUST not be called with any deeper locks held // MUST be called only by parent thread // Note: listener thread is the "main" event base, which has exited its // loop in order to call this function. void stop_threads(void) { int i; // assoc can call pause_threads(), so we have to stop it first. stop_assoc_maintenance_thread(); if (settings.verbose > 0) fprintf(stderr, "stopped assoc\n"); if (settings.verbose > 0) fprintf(stderr, "asking workers to stop\n"); pthread_mutex_lock(&worker_hang_lock); pthread_mutex_lock(&init_lock); init_count = 0; for (i = 0; i < settings.num_threads; i++) { notify_worker_fd(&threads[i], 0, queue_stop); } wait_for_thread_registration(settings.num_threads); pthread_mutex_unlock(&init_lock); // All of the workers are hung but haven't done cleanup yet. if (settings.verbose > 0) fprintf(stderr, "asking background threads to stop\n"); // stop each side thread. // TODO: Verify these all work if the threads are already stopped stop_item_crawler_thread(CRAWLER_WAIT); if (settings.verbose > 0) fprintf(stderr, "stopped lru crawler\n"); if (settings.lru_maintainer_thread) { stop_lru_maintainer_thread(); if (settings.verbose > 0) fprintf(stderr, "stopped maintainer\n"); } if (settings.slab_reassign) { stop_slab_maintenance_thread(); if (settings.verbose > 0) fprintf(stderr, "stopped slab mover\n"); } logger_stop(); if (settings.verbose > 0) fprintf(stderr, "stopped logger thread\n"); stop_conn_timeout_thread(); if (settings.verbose > 0) fprintf(stderr, "stopped idle timeout thread\n"); // Close all connections then let the workers finally exit. if (settings.verbose > 0) fprintf(stderr, "closing connections\n"); conn_close_all(); pthread_mutex_unlock(&worker_hang_lock); if (settings.verbose > 0) fprintf(stderr, "reaping worker threads\n"); for (i = 0; i < settings.num_threads; i++) { pthread_join(threads[i].thread_id, NULL); } if (settings.verbose > 0) fprintf(stderr, "all background threads stopped\n"); // At this point, every background thread must be stopped. } /* * Initializes a connection queue. */ static void cq_init(CQ *cq) { pthread_mutex_init(&cq->lock, NULL); STAILQ_INIT(&cq->head); cq->cache = cache_create("cq", sizeof(CQ_ITEM), sizeof(char *)); if (cq->cache == NULL) { fprintf(stderr, "Failed to create connection queue cache\n"); exit(EXIT_FAILURE); } } /* * Looks for an item on a connection queue, but doesn't block if there isn't * one. * Returns the item, or NULL if no item is available */ static CQ_ITEM *cq_pop(CQ *cq) { CQ_ITEM *item; pthread_mutex_lock(&cq->lock); item = STAILQ_FIRST(&cq->head); if (item != NULL) { STAILQ_REMOVE_HEAD(&cq->head, i_next); } pthread_mutex_unlock(&cq->lock); return item; } /* * Adds an item to a connection queue. */ static void cq_push(CQ *cq, CQ_ITEM *item) { pthread_mutex_lock(&cq->lock); STAILQ_INSERT_TAIL(&cq->head, item, i_next); pthread_mutex_unlock(&cq->lock); } /* * Returns a fresh connection queue item. */ static CQ_ITEM *cqi_new(CQ *cq) { CQ_ITEM *item = cache_alloc(cq->cache); if (item == NULL) { STATS_LOCK(); stats.malloc_fails++; STATS_UNLOCK(); } return item; } /* * Frees a connection queue item (adds it to the freelist.) */ static void cqi_free(CQ *cq, CQ_ITEM *item) { cache_free(cq->cache, item); } // TODO: Skip notify if queue wasn't empty? // - Requires cq_push() returning a "was empty" flag // - Requires event handling loop to pop the entire queue and work from that // instead of the ev_count work there now. // In testing this does result in a large performance uptick, but unclear how // much that will transfer from a synthetic benchmark. static void notify_worker(LIBEVENT_THREAD *t, CQ_ITEM *item) { cq_push(t->ev_queue, item); #ifdef HAVE_EVENTFD uint64_t u = 1; if (write(t->notify_event_fd, &u, sizeof(uint64_t)) != sizeof(uint64_t)) { perror("failed writing to worker eventfd"); /* TODO: This is a fatal problem. Can it ever happen temporarily? */ } #else char buf[1] = "c"; if (write(t->notify_send_fd, buf, 1) != 1) { perror("Failed writing to notify pipe"); /* TODO: This is a fatal problem. Can it ever happen temporarily? */ } #endif } // NOTE: An external func that takes a conn *c might be cleaner overall. static void notify_worker_fd(LIBEVENT_THREAD *t, int sfd, enum conn_queue_item_modes mode) { CQ_ITEM *item; while ( (item = cqi_new(t->ev_queue)) == NULL ) { // NOTE: most callers of this function cannot fail, but mallocs in // theory can fail. Small mallocs essentially never do without also // killing the process. Syscalls can also fail but the original code // never handled this either. // As a compromise, I'm leaving this note and this loop: This alloc // cannot fail, but pre-allocating the data is too much code in an // area I want to keep more lean. If this CQ business becomes a more // generic queue I'll reconsider. } item->mode = mode; item->sfd = sfd; notify_worker(t, item); } /* * Creates a worker thread. */ static void create_worker(void *(*func)(void *), void *arg) { pthread_attr_t attr; int ret; pthread_attr_init(&attr); if ((ret = pthread_create(&((LIBEVENT_THREAD*)arg)->thread_id, &attr, func, arg)) != 0) { fprintf(stderr, "Can't create thread: %s\n", strerror(ret)); exit(1); } thread_setname(((LIBEVENT_THREAD*)arg)->thread_id, "mc-worker"); } /* * Sets whether or not we accept new connections. */ void accept_new_conns(const bool do_accept) { pthread_mutex_lock(&conn_lock); do_accept_new_conns(do_accept); pthread_mutex_unlock(&conn_lock); } /****************************** LIBEVENT THREADS *****************************/ /* * Set up a thread's information. */ static void setup_thread(LIBEVENT_THREAD *me) { #if defined(LIBEVENT_VERSION_NUMBER) && LIBEVENT_VERSION_NUMBER >= 0x02000101 struct event_config *ev_config; ev_config = event_config_new(); event_config_set_flag(ev_config, EVENT_BASE_FLAG_NOLOCK); me->base = event_base_new_with_config(ev_config); event_config_free(ev_config); #else me->base = event_init(); #endif if (! me->base) { fprintf(stderr, "Can't allocate event base\n"); exit(1); } /* Listen for notifications from other threads */ #ifdef HAVE_EVENTFD event_set(&me->notify_event, me->notify_event_fd, EV_READ | EV_PERSIST, thread_libevent_process, me); #else event_set(&me->notify_event, me->notify_receive_fd, EV_READ | EV_PERSIST, thread_libevent_process, me); #endif event_base_set(me->base, &me->notify_event); if (event_add(&me->notify_event, 0) == -1) { fprintf(stderr, "Can't monitor libevent notify pipe\n"); exit(1); } me->ev_queue = malloc(sizeof(struct conn_queue)); if (me->ev_queue == NULL) { perror("Failed to allocate memory for connection queue"); exit(EXIT_FAILURE); } cq_init(me->ev_queue); if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) { perror("Failed to initialize mutex"); exit(EXIT_FAILURE); } me->rbuf_cache = cache_create("rbuf", READ_BUFFER_SIZE, sizeof(char *)); if (me->rbuf_cache == NULL) { fprintf(stderr, "Failed to create read buffer cache\n"); exit(EXIT_FAILURE); } // Note: we were cleanly passing in num_threads before, but this now // relies on settings globals too much. if (settings.read_buf_mem_limit) { int limit = settings.read_buf_mem_limit / settings.num_threads; if (limit < READ_BUFFER_SIZE) { limit = 1; } else { limit = limit / READ_BUFFER_SIZE; } cache_set_limit(me->rbuf_cache, limit); } me->io_cache = cache_create("io", sizeof(io_pending_t), sizeof(char*)); if (me->io_cache == NULL) { fprintf(stderr, "Failed to create IO object cache\n"); exit(EXIT_FAILURE); } #ifdef TLS if (settings.ssl_enabled) { me->ssl_wbuf = (char *)malloc((size_t)settings.ssl_wbuf_size); if (me->ssl_wbuf == NULL) { fprintf(stderr, "Failed to allocate the SSL write buffer\n"); exit(EXIT_FAILURE); } } #endif #ifdef EXTSTORE // me->storage is set just before this function is called. if (me->storage) { thread_io_queue_add(me, IO_QUEUE_EXTSTORE, me->storage, storage_submit_cb); } #endif #ifdef PROXY thread_io_queue_add(me, IO_QUEUE_PROXY, settings.proxy_ctx, proxy_submit_cb); // TODO: maybe register hooks to be called here from sub-packages? ie; // extstore, TLS, proxy. if (settings.proxy_enabled) { proxy_thread_init(settings.proxy_ctx, me); } #endif thread_io_queue_add(me, IO_QUEUE_NONE, NULL, NULL); } /* * Worker thread: main event loop */ static void *worker_libevent(void *arg) { LIBEVENT_THREAD *me = arg; /* Any per-thread setup can happen here; memcached_thread_init() will block until * all threads have finished initializing. */ me->l = logger_create(); me->lru_bump_buf = item_lru_bump_buf_create(); if (me->l == NULL || me->lru_bump_buf == NULL) { abort(); } if (settings.drop_privileges) { drop_worker_privileges(); } register_thread_initialized(); event_base_loop(me->base, 0); // same mechanism used to watch for all threads exiting. register_thread_initialized(); event_base_free(me->base); return NULL; } /* * Processes an incoming "connection event" item. This is called when * input arrives on the libevent wakeup pipe. */ // Syscalls can be expensive enough that handling a few of them once here can // save both throughput and overall latency. #define MAX_PIPE_EVENTS 32 static void thread_libevent_process(evutil_socket_t fd, short which, void *arg) { LIBEVENT_THREAD *me = arg; CQ_ITEM *item; conn *c; uint64_t ev_count = 0; // max number of events to loop through this run. #ifdef HAVE_EVENTFD // NOTE: unlike pipe we aren't limiting the number of events per read. // However we do limit the number of queue pulls to what the count was at // the time of this function firing. if (read(fd, &ev_count, sizeof(uint64_t)) != sizeof(uint64_t)) { if (settings.verbose > 0) fprintf(stderr, "Can't read from libevent pipe\n"); return; } #else char buf[MAX_PIPE_EVENTS]; ev_count = read(fd, buf, MAX_PIPE_EVENTS); if (ev_count == 0) { if (settings.verbose > 0) fprintf(stderr, "Can't read from libevent pipe\n"); return; } #endif for (int x = 0; x < ev_count; x++) { item = cq_pop(me->ev_queue); if (item == NULL) { return; } switch (item->mode) { case queue_new_conn: c = conn_new(item->sfd, item->init_state, item->event_flags, item->read_buffer_size, item->transport, me->base, item->ssl, item->conntag, item->bproto); if (c == NULL) { if (IS_UDP(item->transport)) { fprintf(stderr, "Can't listen for events on UDP socket\n"); exit(1); } else { if (settings.verbose > 0) { fprintf(stderr, "Can't listen for events on fd %d\n", item->sfd); } #ifdef TLS if (item->ssl) { SSL_shutdown(item->ssl); SSL_free(item->ssl); } #endif close(item->sfd); } } else { c->thread = me; conn_io_queue_setup(c); #ifdef TLS if (settings.ssl_enabled && c->ssl != NULL) { assert(c->thread && c->thread->ssl_wbuf); c->ssl_wbuf = c->thread->ssl_wbuf; } #endif } break; case queue_pause: /* we were told to pause and report in */ register_thread_initialized(); break; case queue_timeout: /* a client socket timed out */ conn_close_idle(conns[item->sfd]); break; case queue_redispatch: /* a side thread redispatched a client connection */ conn_worker_readd(conns[item->sfd]); break; case queue_stop: /* asked to stop */ event_base_loopexit(me->base, NULL); break; case queue_return_io: /* getting an individual IO object back */ conn_io_queue_return(item->io); break; #ifdef PROXY case queue_proxy_reload: proxy_worker_reload(settings.proxy_ctx, me); break; #endif } cqi_free(me->ev_queue, item); } } // Interface is slightly different on various platforms. // On linux, at least, the len limit is 16 bytes. #define THR_NAME_MAXLEN 16 void thread_setname(pthread_t thread, const char *name) { assert(strlen(name) < THR_NAME_MAXLEN); #if defined(__linux__) pthread_setname_np(thread, name); #endif } #undef THR_NAME_MAXLEN // NOTE: need better encapsulation. // used by the proxy module to iterate the worker threads. LIBEVENT_THREAD *get_worker_thread(int id) { return &threads[id]; } /* Which thread we assigned a connection to most recently. */ static int last_thread = -1; /* Last thread we assigned to a connection based on napi_id */ static int last_thread_by_napi_id = -1; static LIBEVENT_THREAD *select_thread_round_robin(void) { int tid = (last_thread + 1) % settings.num_threads; last_thread = tid; return threads + tid; } static void reset_threads_napi_id(void) { LIBEVENT_THREAD *thread; int i; for (i = 0; i < settings.num_threads; i++) { thread = threads + i; thread->napi_id = 0; } last_thread_by_napi_id = -1; } /* Select a worker thread based on the NAPI ID of an incoming connection * request. NAPI ID is a globally unique ID that identifies a NIC RX queue * on which a flow is received. */ static LIBEVENT_THREAD *select_thread_by_napi_id(int sfd) { LIBEVENT_THREAD *thread; int napi_id, err, i; socklen_t len; int tid = -1; len = sizeof(socklen_t); err = getsockopt(sfd, SOL_SOCKET, SO_INCOMING_NAPI_ID, &napi_id, &len); if ((err == -1) || (napi_id == 0)) { STATS_LOCK(); stats.round_robin_fallback++; STATS_UNLOCK(); return select_thread_round_robin(); } select: for (i = 0; i < settings.num_threads; i++) { thread = threads + i; if (last_thread_by_napi_id < i) { thread->napi_id = napi_id; last_thread_by_napi_id = i; tid = i; break; } if (thread->napi_id == napi_id) { tid = i; break; } } if (tid == -1) { STATS_LOCK(); stats.unexpected_napi_ids++; STATS_UNLOCK(); reset_threads_napi_id(); goto select; } return threads + tid; } /* * Dispatches a new connection to another thread. This is only ever called * from the main thread, either during initialization (for UDP) or because * of an incoming connection. */ void dispatch_conn_new(int sfd, enum conn_states init_state, int event_flags, int read_buffer_size, enum network_transport transport, void *ssl, uint64_t conntag, enum protocol bproto) { CQ_ITEM *item = NULL; LIBEVENT_THREAD *thread; if (!settings.num_napi_ids) thread = select_thread_round_robin(); else thread = select_thread_by_napi_id(sfd); item = cqi_new(thread->ev_queue); if (item == NULL) { close(sfd); /* given that malloc failed this may also fail, but let's try */ fprintf(stderr, "Failed to allocate memory for connection object\n"); return; } item->sfd = sfd; item->init_state = init_state; item->event_flags = event_flags; item->read_buffer_size = read_buffer_size; item->transport = transport; item->mode = queue_new_conn; item->ssl = ssl; item->conntag = conntag; item->bproto = bproto; MEMCACHED_CONN_DISPATCH(sfd, (int64_t)thread->thread_id); notify_worker(thread, item); } /* * Re-dispatches a connection back to the original thread. Can be called from * any side thread borrowing a connection. */ void redispatch_conn(conn *c) { notify_worker_fd(c->thread, c->sfd, queue_redispatch); } void timeout_conn(conn *c) { notify_worker_fd(c->thread, c->sfd, queue_timeout); } #ifdef PROXY void proxy_reload_notify(LIBEVENT_THREAD *t) { notify_worker_fd(t, 0, queue_proxy_reload); } #endif void return_io_pending(io_pending_t *io) { CQ_ITEM *item = cqi_new(io->thread->ev_queue); if (item == NULL) { // TODO: how can we avoid this? // In the main case I just loop, since a malloc failure here for a // tiny object that's generally in a fixed size queue is going to // implode shortly. return; } item->mode = queue_return_io; item->io = io; notify_worker(io->thread, item); } /* This misses the allow_new_conns flag :( */ void sidethread_conn_close(conn *c) { if (settings.verbose > 1) fprintf(stderr, "<%d connection closing from side thread.\n", c->sfd); c->state = conn_closing; // redispatch will see closing flag and properly close connection. redispatch_conn(c); return; } /********************************* ITEM ACCESS *******************************/ /* * Allocates a new item. */ item *item_alloc(const char *key, size_t nkey, int flags, rel_time_t exptime, int nbytes) { item *it; /* do_item_alloc handles its own locks */ it = do_item_alloc(key, nkey, flags, exptime, nbytes); return it; } /* * Returns an item if it hasn't been marked as expired, * lazy-expiring as needed. */ item *item_get(const char *key, const size_t nkey, LIBEVENT_THREAD *t, const bool do_update) { item *it; uint32_t hv; hv = hash(key, nkey); item_lock(hv); it = do_item_get(key, nkey, hv, t, do_update); item_unlock(hv); return it; } // returns an item with the item lock held. // lock will still be held even if return is NULL, allowing caller to replace // an item atomically if desired. item *item_get_locked(const char *key, const size_t nkey, LIBEVENT_THREAD *t, const bool do_update, uint32_t *hv) { item *it; *hv = hash(key, nkey); item_lock(*hv); it = do_item_get(key, nkey, *hv, t, do_update); return it; } item *item_touch(const char *key, size_t nkey, uint32_t exptime, LIBEVENT_THREAD *t) { item *it; uint32_t hv; hv = hash(key, nkey); item_lock(hv); it = do_item_touch(key, nkey, exptime, hv, t); item_unlock(hv); return it; } /* * Links an item into the LRU and hashtable. */ int item_link(item *item) { int ret; uint32_t hv; hv = hash(ITEM_key(item), item->nkey); item_lock(hv); ret = do_item_link(item, hv); item_unlock(hv); return ret; } /* * Decrements the reference count on an item and adds it to the freelist if * needed. */ void item_remove(item *item) { uint32_t hv; hv = hash(ITEM_key(item), item->nkey); item_lock(hv); do_item_remove(item); item_unlock(hv); } /* * Replaces one item with another in the hashtable. * Unprotected by a mutex lock since the core server does not require * it to be thread-safe. */ int item_replace(item *old_it, item *new_it, const uint32_t hv) { return do_item_replace(old_it, new_it, hv); } /* * Unlinks an item from the LRU and hashtable. */ void item_unlink(item *item) { uint32_t hv; hv = hash(ITEM_key(item), item->nkey); item_lock(hv); do_item_unlink(item, hv); item_unlock(hv); } /* * Does arithmetic on a numeric item value. */ enum delta_result_type add_delta(LIBEVENT_THREAD *t, const char *key, const size_t nkey, bool incr, const int64_t delta, char *buf, uint64_t *cas) { enum delta_result_type ret; uint32_t hv; hv = hash(key, nkey); item_lock(hv); ret = do_add_delta(t, key, nkey, incr, delta, buf, cas, hv, NULL); item_unlock(hv); return ret; } /* * Stores an item in the cache (high level, obeys set/add/replace semantics) */ enum store_item_type store_item(item *item, int comm, LIBEVENT_THREAD *t, int *nbytes, uint64_t *cas, bool cas_stale) { enum store_item_type ret; uint32_t hv; hv = hash(ITEM_key(item), item->nkey); item_lock(hv); ret = do_store_item(item, comm, t, hv, nbytes, cas, cas_stale); item_unlock(hv); return ret; } /******************************* GLOBAL STATS ******************************/ void STATS_LOCK(void) { pthread_mutex_lock(&stats_lock); } void STATS_UNLOCK(void) { pthread_mutex_unlock(&stats_lock); } void threadlocal_stats_reset(void) { int ii; for (ii = 0; ii < settings.num_threads; ++ii) { pthread_mutex_lock(&threads[ii].stats.mutex); #define X(name) threads[ii].stats.name = 0; THREAD_STATS_FIELDS #ifdef EXTSTORE EXTSTORE_THREAD_STATS_FIELDS #endif #ifdef PROXY PROXY_THREAD_STATS_FIELDS #endif #undef X memset(&threads[ii].stats.slab_stats, 0, sizeof(threads[ii].stats.slab_stats)); memset(&threads[ii].stats.lru_hits, 0, sizeof(uint64_t) * POWER_LARGEST); pthread_mutex_unlock(&threads[ii].stats.mutex); } } void threadlocal_stats_aggregate(struct thread_stats *stats) { int ii, sid; /* The struct has a mutex, but we can safely set the whole thing * to zero since it is unused when aggregating. */ memset(stats, 0, sizeof(*stats)); for (ii = 0; ii < settings.num_threads; ++ii) { pthread_mutex_lock(&threads[ii].stats.mutex); #define X(name) stats->name += threads[ii].stats.name; THREAD_STATS_FIELDS #ifdef EXTSTORE EXTSTORE_THREAD_STATS_FIELDS #endif #ifdef PROXY PROXY_THREAD_STATS_FIELDS #endif #undef X for (sid = 0; sid < MAX_NUMBER_OF_SLAB_CLASSES; sid++) { #define X(name) stats->slab_stats[sid].name += \ threads[ii].stats.slab_stats[sid].name; SLAB_STATS_FIELDS #undef X } for (sid = 0; sid < POWER_LARGEST; sid++) { stats->lru_hits[sid] += threads[ii].stats.lru_hits[sid]; stats->slab_stats[CLEAR_LRU(sid)].get_hits += threads[ii].stats.lru_hits[sid]; } stats->read_buf_count += threads[ii].rbuf_cache->total; stats->read_buf_bytes += threads[ii].rbuf_cache->total * READ_BUFFER_SIZE; stats->read_buf_bytes_free += threads[ii].rbuf_cache->freecurr * READ_BUFFER_SIZE; pthread_mutex_unlock(&threads[ii].stats.mutex); } } void slab_stats_aggregate(struct thread_stats *stats, struct slab_stats *out) { int sid; memset(out, 0, sizeof(*out)); for (sid = 0; sid < MAX_NUMBER_OF_SLAB_CLASSES; sid++) { #define X(name) out->name += stats->slab_stats[sid].name; SLAB_STATS_FIELDS #undef X } } /* * Initializes the thread subsystem, creating various worker threads. * * nthreads Number of worker event handler threads to spawn */ void memcached_thread_init(int nthreads, void *arg) { int i; int power; for (i = 0; i < POWER_LARGEST; i++) { pthread_mutex_init(&lru_locks[i], NULL); } pthread_mutex_init(&worker_hang_lock, NULL); pthread_mutex_init(&init_lock, NULL); pthread_cond_init(&init_cond, NULL); /* Want a wide lock table, but don't waste memory */ if (nthreads < 3) { power = 10; } else if (nthreads < 4) { power = 11; } else if (nthreads < 5) { power = 12; } else if (nthreads <= 10) { power = 13; } else if (nthreads <= 20) { power = 14; } else { /* 32k buckets. just under the hashpower default. */ power = 15; } if (power >= hashpower) { fprintf(stderr, "Hash table power size (%d) cannot be equal to or less than item lock table (%d)\n", hashpower, power); fprintf(stderr, "Item lock table grows with `-t N` (worker threadcount)\n"); fprintf(stderr, "Hash table grows with `-o hashpower=N` \n"); exit(1); } item_lock_count = hashsize(power); item_lock_hashpower = power; item_locks = calloc(item_lock_count, sizeof(pthread_mutex_t)); if (! item_locks) { perror("Can't allocate item locks"); exit(1); } for (i = 0; i < item_lock_count; i++) { pthread_mutex_init(&item_locks[i], NULL); } threads = calloc(nthreads, sizeof(LIBEVENT_THREAD)); if (! threads) { perror("Can't allocate thread descriptors"); exit(1); } for (i = 0; i < nthreads; i++) { #ifdef HAVE_EVENTFD threads[i].notify_event_fd = eventfd(0, EFD_NONBLOCK); if (threads[i].notify_event_fd == -1) { perror("failed creating eventfd for worker thread"); exit(1); } #else int fds[2]; if (pipe(fds)) { perror("Can't create notify pipe"); exit(1); } threads[i].notify_receive_fd = fds[0]; threads[i].notify_send_fd = fds[1]; #endif #ifdef EXTSTORE threads[i].storage = arg; #endif threads[i].thread_baseid = i; setup_thread(&threads[i]); /* Reserve three fds for the libevent base, and two for the pipe */ stats_state.reserved_fds += 5; } /* Create threads after we've done all the libevent setup. */ for (i = 0; i < nthreads; i++) { create_worker(worker_libevent, &threads[i]); } /* Wait for all the threads to set themselves up before returning. */ pthread_mutex_lock(&init_lock); wait_for_thread_registration(nthreads); pthread_mutex_unlock(&init_lock); } memcached-1.6.20/slab_automove_extstore.c0000664000175000017500000001703514426037614015407 00000000000000/* Copyright 2017 Facebook. * * Use and distribution licensed under the BSD license. See * the LICENSE file for full text. */ /* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "memcached.h" #include "slab_automove_extstore.h" #include #include #define MIN_PAGES_FOR_SOURCE 2 #define MIN_PAGES_FOR_RECLAIM 2.5 #define MIN_PAGES_FREE 1.5 struct window_data { uint64_t age; uint64_t dirty; uint64_t evicted; unsigned int excess_free; unsigned int relaxed; }; typedef struct { struct window_data *window_data; struct settings *settings; uint32_t window_size; uint32_t window_cur; uint32_t item_size; double max_age_ratio; double free_ratio; bool pool_filled_once; unsigned int global_pool_watermark; item_stats_automove iam_before[MAX_NUMBER_OF_SLAB_CLASSES]; item_stats_automove iam_after[MAX_NUMBER_OF_SLAB_CLASSES]; slab_stats_automove sam_before[MAX_NUMBER_OF_SLAB_CLASSES]; slab_stats_automove sam_after[MAX_NUMBER_OF_SLAB_CLASSES]; } slab_automove; void *slab_automove_extstore_init(struct settings *settings) { uint32_t window_size = settings->slab_automove_window; double max_age_ratio = settings->slab_automove_ratio; slab_automove *a = calloc(1, sizeof(slab_automove)); if (a == NULL) return NULL; a->window_data = calloc(window_size * MAX_NUMBER_OF_SLAB_CLASSES, sizeof(struct window_data)); a->window_size = window_size; a->max_age_ratio = max_age_ratio; a->free_ratio = settings->slab_automove_freeratio; a->item_size = settings->ext_item_size; a->settings = settings; a->pool_filled_once = false; if (a->window_data == NULL) { if (a->window_data) free(a->window_data); free(a); return NULL; } // do a dry run to fill the before structs fill_item_stats_automove(a->iam_before); fill_slab_stats_automove(a->sam_before); return (void *)a; } void slab_automove_extstore_free(void *arg) { slab_automove *a = (slab_automove *)arg; free(a->window_data); free(a); } static void window_sum(struct window_data *wd, struct window_data *w, uint32_t size) { for (int x = 0; x < size; x++) { struct window_data *d = &wd[x]; w->age += d->age; w->dirty += d->dirty; w->evicted += d->evicted; w->excess_free += d->excess_free; w->relaxed += d->relaxed; } } static int global_pool_check(slab_automove *a) { bool mem_limit_reached; unsigned int free = a->global_pool_watermark; unsigned int count = global_page_pool_size(&mem_limit_reached); if (!mem_limit_reached) return 0; if (count < free) { a->pool_filled_once = true; return 1; } else { a->pool_filled_once = true; } return 0; } /* A percentage of memory is configured to be held "free" as buffers for the * external storage system. * % of global memory is desired in the global page pool * each slab class has a % of free chunks desired based on how much memory is * currently in the class. This allows time for extstore to flush data when * spikes or waves of set data arrive. * The global page pool reserve acts as a secondary buffer for any slab class, * which helps absorb shifts in which class is active. */ static void memcheck(slab_automove *a) { unsigned int total_pages = 0; // FIXME: is there a cached counter for total pages alloced? // technically we only really need to do this once as the pages are // prefilled and ratio isn't a runtime change. for (int n = 1; n < MAX_NUMBER_OF_SLAB_CLASSES; n++) { slab_stats_automove *sam = &a->sam_after[n]; total_pages += sam->total_pages; } // always update what remains in the global page pool total_pages += a->sam_after[0].total_pages; a->global_pool_watermark = total_pages * a->free_ratio; if (a->global_pool_watermark < 2) a->global_pool_watermark = 2; settings.ext_global_pool_min = a->global_pool_watermark; } static struct window_data *get_window_data(slab_automove *a, int class) { int w_offset = class * a->window_size; return &a->window_data[w_offset + (a->window_cur % a->window_size)]; } void slab_automove_extstore_run(void *arg, int *src, int *dst) { slab_automove *a = (slab_automove *)arg; int n; struct window_data w_sum; int oldest = -1; uint64_t oldest_age = 0; bool too_free = false; *src = -1; *dst = -1; int global_low = global_pool_check(a); // fill after structs fill_item_stats_automove(a->iam_after); fill_slab_stats_automove(a->sam_after); a->window_cur++; memcheck(a); // iterate slabs for (n = POWER_SMALLEST; n < MAX_NUMBER_OF_SLAB_CLASSES; n++) { bool small_slab = a->sam_before[n].chunk_size < a->item_size ? true : false; struct window_data *wd = get_window_data(a, n); int w_offset = n * a->window_size; memset(wd, 0, sizeof(struct window_data)); unsigned int free_target = a->sam_after[n].chunks_per_page * MIN_PAGES_FREE; // if page delta, oom, or evicted delta, mark window dirty // classes marked dirty cannot donate memory back to global pool. if (a->iam_after[n].evicted - a->iam_before[n].evicted > 0 || a->iam_after[n].outofmemory - a->iam_before[n].outofmemory > 0) { wd->evicted = 1; wd->dirty = 1; } if (a->sam_after[n].total_pages - a->sam_before[n].total_pages > 0) { wd->dirty = 1; } // double the free requirements means we may have memory we can // reclaim to global, if it stays this way for the whole window. if (a->sam_after[n].free_chunks > (free_target * 2)) { wd->excess_free = 1; } // set age into window wd->age = a->iam_after[n].age; // summarize the window-up-to-now. memset(&w_sum, 0, sizeof(struct window_data)); window_sum(&a->window_data[w_offset], &w_sum, a->window_size); // grab age as average of window total uint64_t age = w_sum.age / a->window_size; // if > N free chunks and not dirty, reclaim memory // small slab classes aren't age balanced and rely more on global // pool. reclaim them more aggressively. if (a->sam_after[n].free_chunks > a->sam_after[n].chunks_per_page * MIN_PAGES_FOR_RECLAIM && w_sum.dirty == 0) { if (small_slab) { *src = n; *dst = 0; too_free = true; } else if (!small_slab && w_sum.excess_free >= a->window_size) { // If large slab and free chunks haven't decreased for a full // window, reclaim pages. *src = n; *dst = 0; too_free = true; } } if (!small_slab) { // if oldest and have enough pages, is oldest if (age > oldest_age && a->sam_after[n].total_pages > MIN_PAGES_FOR_SOURCE) { oldest = n; oldest_age = age; } } } memcpy(a->iam_before, a->iam_after, sizeof(item_stats_automove) * MAX_NUMBER_OF_SLAB_CLASSES); memcpy(a->sam_before, a->sam_after, sizeof(slab_stats_automove) * MAX_NUMBER_OF_SLAB_CLASSES); // only make decisions if window has filled once. if (a->window_cur < a->window_size) return; if (!too_free && global_low && oldest != -1) { *src = oldest; *dst = 0; } return; } memcached-1.6.20/xxhash.h0000664000175000017500000060446414302037501012116 00000000000000/* * xxHash - Extremely Fast Hash algorithm * Header File * Copyright (C) 2012-2020 Yann Collet * * BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php) * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following disclaimer * in the documentation and/or other materials provided with the * distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * You can contact the author at: * - xxHash homepage: https://www.xxhash.com * - xxHash source repository: https://github.com/Cyan4973/xxHash */ /*! * @mainpage xxHash * * @file xxhash.h * xxHash prototypes and implementation */ /* TODO: update */ /* Notice extracted from xxHash homepage: xxHash is an extremely fast hash algorithm, running at RAM speed limits. It also successfully passes all tests from the SMHasher suite. Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz) Name Speed Q.Score Author xxHash 5.4 GB/s 10 CrapWow 3.2 GB/s 2 Andrew MurmurHash 3a 2.7 GB/s 10 Austin Appleby SpookyHash 2.0 GB/s 10 Bob Jenkins SBox 1.4 GB/s 9 Bret Mulvey Lookup3 1.2 GB/s 9 Bob Jenkins SuperFastHash 1.2 GB/s 1 Paul Hsieh CityHash64 1.05 GB/s 10 Pike & Alakuijala FNV 0.55 GB/s 5 Fowler, Noll, Vo CRC32 0.43 GB/s 9 MD5-32 0.33 GB/s 10 Ronald L. Rivest SHA1-32 0.28 GB/s 10 Q.Score is a measure of quality of the hash function. It depends on successfully passing SMHasher test set. 10 is a perfect score. Note: SMHasher's CRC32 implementation is not the fastest one. Other speed-oriented implementations can be faster, especially in combination with PCLMUL instruction: https://fastcompression.blogspot.com/2019/03/presenting-xxh3.html?showComment=1552696407071#c3490092340461170735 A 64-bit version, named XXH64, is available since r35. It offers much better speed, but for 64-bit applications only. Name Speed on 64 bits Speed on 32 bits XXH64 13.8 GB/s 1.9 GB/s XXH32 6.8 GB/s 6.0 GB/s */ #if defined (__cplusplus) extern "C" { #endif /* **************************** * INLINE mode ******************************/ /*! * XXH_INLINE_ALL (and XXH_PRIVATE_API) * Use these build macros to inline xxhash into the target unit. * Inlining improves performance on small inputs, especially when the length is * expressed as a compile-time constant: * * https://fastcompression.blogspot.com/2018/03/xxhash-for-small-keys-impressive-power.html * * It also keeps xxHash symbols private to the unit, so they are not exported. * * Usage: * #define XXH_INLINE_ALL * #include "xxhash.h" * * Do not compile and link xxhash.o as a separate object, as it is not useful. */ #if (defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)) \ && !defined(XXH_INLINE_ALL_31684351384) /* this section should be traversed only once */ # define XXH_INLINE_ALL_31684351384 /* give access to the advanced API, required to compile implementations */ # undef XXH_STATIC_LINKING_ONLY /* avoid macro redef */ # define XXH_STATIC_LINKING_ONLY /* make all functions private */ # undef XXH_PUBLIC_API # if defined(__GNUC__) # define XXH_PUBLIC_API static __inline __attribute__((unused)) # elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) # define XXH_PUBLIC_API static inline # elif defined(_MSC_VER) # define XXH_PUBLIC_API static __inline # else /* note: this version may generate warnings for unused static functions */ # define XXH_PUBLIC_API static # endif /* * This part deals with the special case where a unit wants to inline xxHash, * but "xxhash.h" has previously been included without XXH_INLINE_ALL, such * as part of some previously included *.h header file. * Without further action, the new include would just be ignored, * and functions would effectively _not_ be inlined (silent failure). * The following macros solve this situation by prefixing all inlined names, * avoiding naming collision with previous inclusions. */ # ifdef XXH_NAMESPACE # error "XXH_INLINE_ALL with XXH_NAMESPACE is not supported" /* * Note: Alternative: #undef all symbols (it's a pretty large list). * Without #error: it compiles, but functions are actually not inlined. */ # endif # define XXH_NAMESPACE XXH_INLINE_ /* * Some identifiers (enums, type names) are not symbols, but they must * still be renamed to avoid redeclaration. * Alternative solution: do not redeclare them. * However, this requires some #ifdefs, and is a more dispersed action. * Meanwhile, renaming can be achieved in a single block */ # define XXH_IPREF(Id) XXH_INLINE_ ## Id # define XXH_OK XXH_IPREF(XXH_OK) # define XXH_ERROR XXH_IPREF(XXH_ERROR) # define XXH_errorcode XXH_IPREF(XXH_errorcode) # define XXH32_canonical_t XXH_IPREF(XXH32_canonical_t) # define XXH64_canonical_t XXH_IPREF(XXH64_canonical_t) # define XXH128_canonical_t XXH_IPREF(XXH128_canonical_t) # define XXH32_state_s XXH_IPREF(XXH32_state_s) # define XXH32_state_t XXH_IPREF(XXH32_state_t) # define XXH64_state_s XXH_IPREF(XXH64_state_s) # define XXH64_state_t XXH_IPREF(XXH64_state_t) # define XXH3_state_s XXH_IPREF(XXH3_state_s) # define XXH3_state_t XXH_IPREF(XXH3_state_t) # define XXH128_hash_t XXH_IPREF(XXH128_hash_t) /* Ensure the header is parsed again, even if it was previously included */ # undef XXHASH_H_5627135585666179 # undef XXHASH_H_STATIC_13879238742 #endif /* XXH_INLINE_ALL || XXH_PRIVATE_API */ /* **************************************************************** * Stable API *****************************************************************/ #ifndef XXHASH_H_5627135585666179 #define XXHASH_H_5627135585666179 1 /*! * @defgroup public Public API * Contains details on the public xxHash functions. * @{ */ /* specific declaration modes for Windows */ #if !defined(XXH_INLINE_ALL) && !defined(XXH_PRIVATE_API) # if defined(WIN32) && defined(_MSC_VER) && (defined(XXH_IMPORT) || defined(XXH_EXPORT)) # ifdef XXH_EXPORT # define XXH_PUBLIC_API __declspec(dllexport) # elif XXH_IMPORT # define XXH_PUBLIC_API __declspec(dllimport) # endif # else # define XXH_PUBLIC_API /* do nothing */ # endif #endif #ifdef XXH_DOXYGEN /*! * @brief Emulate a namespace by transparently prefixing all symbols. * * If you want to include _and expose_ xxHash functions from within your own * library, but also want to avoid symbol collisions with other libraries which * may also include xxHash, you can use XXH_NAMESPACE to automatically prefix * any public symbol from xxhash library with the value of XXH_NAMESPACE * (therefore, avoid empty or numeric values). * * Note that no change is required within the calling program as long as it * includes `xxhash.h`: Regular symbol names will be automatically translated * by this header. */ # define XXH_NAMESPACE /* YOUR NAME HERE */ # undef XXH_NAMESPACE #endif #ifdef XXH_NAMESPACE # define XXH_CAT(A,B) A##B # define XXH_NAME2(A,B) XXH_CAT(A,B) # define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber) /* XXH32 */ # define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32) # define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState) # define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState) # define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset) # define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update) # define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest) # define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState) # define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash) # define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical) /* XXH64 */ # define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64) # define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState) # define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState) # define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset) # define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update) # define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest) # define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState) # define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash) # define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical) /* XXH3_64bits */ # define XXH3_64bits XXH_NAME2(XXH_NAMESPACE, XXH3_64bits) # define XXH3_64bits_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_withSecret) # define XXH3_64bits_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_withSeed) # define XXH3_createState XXH_NAME2(XXH_NAMESPACE, XXH3_createState) # define XXH3_freeState XXH_NAME2(XXH_NAMESPACE, XXH3_freeState) # define XXH3_copyState XXH_NAME2(XXH_NAMESPACE, XXH3_copyState) # define XXH3_64bits_reset XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset) # define XXH3_64bits_reset_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset_withSeed) # define XXH3_64bits_reset_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset_withSecret) # define XXH3_64bits_update XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_update) # define XXH3_64bits_digest XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_digest) # define XXH3_generateSecret XXH_NAME2(XXH_NAMESPACE, XXH3_generateSecret) /* XXH3_128bits */ # define XXH128 XXH_NAME2(XXH_NAMESPACE, XXH128) # define XXH3_128bits XXH_NAME2(XXH_NAMESPACE, XXH3_128bits) # define XXH3_128bits_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_withSeed) # define XXH3_128bits_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_withSecret) # define XXH3_128bits_reset XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset) # define XXH3_128bits_reset_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset_withSeed) # define XXH3_128bits_reset_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset_withSecret) # define XXH3_128bits_update XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_update) # define XXH3_128bits_digest XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_digest) # define XXH128_isEqual XXH_NAME2(XXH_NAMESPACE, XXH128_isEqual) # define XXH128_cmp XXH_NAME2(XXH_NAMESPACE, XXH128_cmp) # define XXH128_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH128_canonicalFromHash) # define XXH128_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH128_hashFromCanonical) #endif /* ************************************* * Version ***************************************/ #define XXH_VERSION_MAJOR 0 #define XXH_VERSION_MINOR 8 #define XXH_VERSION_RELEASE 0 #define XXH_VERSION_NUMBER (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE) /*! * @brief Obtains the xxHash version. * * This is only useful when xxHash is compiled as a shared library, as it is * independent of the version defined in the header. * * @return `XXH_VERSION_NUMBER` as of when the function was compiled. */ XXH_PUBLIC_API unsigned XXH_versionNumber (void); /* **************************** * Definitions ******************************/ #include /* size_t */ typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode; /*-********************************************************************** * 32-bit hash ************************************************************************/ #if defined(XXH_DOXYGEN) /* Don't show include */ /*! * @brief An unsigned 32-bit integer. * * Not necessarily defined to `uint32_t` but functionally equivalent. */ typedef uint32_t XXH32_hash_t; #elif !defined (__VMS) \ && (defined (__cplusplus) \ || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) # include typedef uint32_t XXH32_hash_t; #else # include # if UINT_MAX == 0xFFFFFFFFUL typedef unsigned int XXH32_hash_t; # else # if ULONG_MAX == 0xFFFFFFFFUL typedef unsigned long XXH32_hash_t; # else # error "unsupported platform: need a 32-bit type" # endif # endif #endif /*! * @} * * @defgroup xxh32_family XXH32 family * @ingroup public * Contains functions used in the classic 32-bit xxHash algorithm. * * @note * XXH32 is considered rather weak by today's standards. * The @ref xxh3_family provides competitive speed for both 32-bit and 64-bit * systems, and offers true 64/128 bit hash results. It provides a superior * level of dispersion, and greatly reduces the risks of collisions. * * @see @ref xxh64_family, @ref xxh3_family : Other xxHash families * @see @ref xxh32_impl for implementation details * @{ */ /*! * @brief Calculates the 32-bit hash of @p input using xxHash32. * * Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark): 5.4 GB/s * * @param input The block of data to be hashed, at least @p length bytes in size. * @param length The length of @p input, in bytes. * @param seed The 32-bit seed to alter the hash's output predictably. * * @pre * The memory between @p input and @p input + @p length must be valid, * readable, contiguous memory. However, if @p length is `0`, @p input may be * `NULL`. In C++, this also must be *TriviallyCopyable*. * * @return The calculated 32-bit hash value. * * @see * XXH64(), XXH3_64bits_withSeed(), XXH3_128bits_withSeed(), XXH128(): * Direct equivalents for the other variants of xxHash. * @see * XXH32_createState(), XXH32_update(), XXH32_digest(): Streaming version. */ XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, XXH32_hash_t seed); /*! * Streaming functions generate the xxHash value from an incremental input. * This method is slower than single-call functions, due to state management. * For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized. * * An XXH state must first be allocated using `XXH*_createState()`. * * Start a new hash by initializing the state with a seed using `XXH*_reset()`. * * Then, feed the hash state by calling `XXH*_update()` as many times as necessary. * * The function returns an error code, with 0 meaning OK, and any other value * meaning there is an error. * * Finally, a hash value can be produced anytime, by using `XXH*_digest()`. * This function returns the nn-bits hash as an int or long long. * * It's still possible to continue inserting input into the hash state after a * digest, and generate new hash values later on by invoking `XXH*_digest()`. * * When done, release the state using `XXH*_freeState()`. * * Example code for incrementally hashing a file: * @code{.c} * #include * #include * #define BUFFER_SIZE 256 * * // Note: XXH64 and XXH3 use the same interface. * XXH32_hash_t * hashFile(FILE* stream) * { * XXH32_state_t* state; * unsigned char buf[BUFFER_SIZE]; * size_t amt; * XXH32_hash_t hash; * * state = XXH32_createState(); // Create a state * assert(state != NULL); // Error check here * XXH32_reset(state, 0xbaad5eed); // Reset state with our seed * while ((amt = fread(buf, 1, sizeof(buf), stream)) != 0) { * XXH32_update(state, buf, amt); // Hash the file in chunks * } * hash = XXH32_digest(state); // Finalize the hash * XXH32_freeState(state); // Clean up * return hash; * } * @endcode */ /*! * @typedef struct XXH32_state_s XXH32_state_t * @brief The opaque state struct for the XXH32 streaming API. * * @see XXH32_state_s for details. */ typedef struct XXH32_state_s XXH32_state_t; /*! * @brief Allocates an @ref XXH32_state_t. * * Must be freed with XXH32_freeState(). * @return An allocated XXH32_state_t on success, `NULL` on failure. */ XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void); /*! * @brief Frees an @ref XXH32_state_t. * * Must be allocated with XXH32_createState(). * @param statePtr A pointer to an @ref XXH32_state_t allocated with @ref XXH32_createState(). * @return XXH_OK. */ XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr); /*! * @brief Copies one @ref XXH32_state_t to another. * * @param dst_state The state to copy to. * @param src_state The state to copy from. * @pre * @p dst_state and @p src_state must not be `NULL` and must not overlap. */ XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state); /*! * @brief Resets an @ref XXH32_state_t to begin a new hash. * * This function resets and seeds a state. Call it before @ref XXH32_update(). * * @param statePtr The state struct to reset. * @param seed The 32-bit seed to alter the hash result predictably. * * @pre * @p statePtr must not be `NULL`. * * @return @ref XXH_OK on success, @ref XXH_ERROR on failure. */ XXH_PUBLIC_API XXH_errorcode XXH32_reset (XXH32_state_t* statePtr, XXH32_hash_t seed); /*! * @brief Consumes a block of @p input to an @ref XXH32_state_t. * * Call this to incrementally consume blocks of data. * * @param statePtr The state struct to update. * @param input The block of data to be hashed, at least @p length bytes in size. * @param length The length of @p input, in bytes. * * @pre * @p statePtr must not be `NULL`. * @pre * The memory between @p input and @p input + @p length must be valid, * readable, contiguous memory. However, if @p length is `0`, @p input may be * `NULL`. In C++, this also must be *TriviallyCopyable*. * * @return @ref XXH_OK on success, @ref XXH_ERROR on failure. */ XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length); /*! * @brief Returns the calculated hash value from an @ref XXH32_state_t. * * @note * Calling XXH32_digest() will not affect @p statePtr, so you can update, * digest, and update again. * * @param statePtr The state struct to calculate the hash from. * * @pre * @p statePtr must not be `NULL`. * * @return The calculated xxHash32 value from that state. */ XXH_PUBLIC_API XXH32_hash_t XXH32_digest (const XXH32_state_t* statePtr); /******* Canonical representation *******/ /* * The default return values from XXH functions are unsigned 32 and 64 bit * integers. * This the simplest and fastest format for further post-processing. * * However, this leaves open the question of what is the order on the byte level, * since little and big endian conventions will store the same number differently. * * The canonical representation settles this issue by mandating big-endian * convention, the same convention as human-readable numbers (large digits first). * * When writing hash values to storage, sending them over a network, or printing * them, it's highly recommended to use the canonical representation to ensure * portability across a wider range of systems, present and future. * * The following functions allow transformation of hash values to and from * canonical format. */ /*! * @brief Canonical (big endian) representation of @ref XXH32_hash_t. */ typedef struct { unsigned char digest[4]; /*!< Hash bytes, big endian */ } XXH32_canonical_t; /*! * @brief Converts an @ref XXH32_hash_t to a big endian @ref XXH32_canonical_t. * * @param dst The @ref XXH32_canonical_t pointer to be stored to. * @param hash The @ref XXH32_hash_t to be converted. * * @pre * @p dst must not be `NULL`. */ XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash); /*! * @brief Converts an @ref XXH32_canonical_t to a native @ref XXH32_hash_t. * * @param src The @ref XXH32_canonical_t to convert. * * @pre * @p src must not be `NULL`. * * @return The converted hash. */ XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src); /*! * @} * @ingroup public * @{ */ #ifndef XXH_NO_LONG_LONG /*-********************************************************************** * 64-bit hash ************************************************************************/ #if defined(XXH_DOXYGEN) /* don't include */ /*! * @brief An unsigned 64-bit integer. * * Not necessarily defined to `uint64_t` but functionally equivalent. */ typedef uint64_t XXH64_hash_t; #elif !defined (__VMS) \ && (defined (__cplusplus) \ || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) # include typedef uint64_t XXH64_hash_t; #else # include # if defined(__LP64__) && ULONG_MAX == 0xFFFFFFFFFFFFFFFFULL /* LP64 ABI says uint64_t is unsigned long */ typedef unsigned long XXH64_hash_t; # else /* the following type must have a width of 64-bit */ typedef unsigned long long XXH64_hash_t; # endif #endif /*! * @} * * @defgroup xxh64_family XXH64 family * @ingroup public * @{ * Contains functions used in the classic 64-bit xxHash algorithm. * * @note * XXH3 provides competitive speed for both 32-bit and 64-bit systems, * and offers true 64/128 bit hash results. It provides a superior level of * dispersion, and greatly reduces the risks of collisions. */ /*! * @brief Calculates the 64-bit hash of @p input using xxHash64. * * This function usually runs faster on 64-bit systems, but slower on 32-bit * systems (see benchmark). * * @param input The block of data to be hashed, at least @p length bytes in size. * @param length The length of @p input, in bytes. * @param seed The 64-bit seed to alter the hash's output predictably. * * @pre * The memory between @p input and @p input + @p length must be valid, * readable, contiguous memory. However, if @p length is `0`, @p input may be * `NULL`. In C++, this also must be *TriviallyCopyable*. * * @return The calculated 64-bit hash. * * @see * XXH32(), XXH3_64bits_withSeed(), XXH3_128bits_withSeed(), XXH128(): * Direct equivalents for the other variants of xxHash. * @see * XXH64_createState(), XXH64_update(), XXH64_digest(): Streaming version. */ XXH_PUBLIC_API XXH64_hash_t XXH64(const void* input, size_t length, XXH64_hash_t seed); /******* Streaming *******/ /*! * @brief The opaque state struct for the XXH64 streaming API. * * @see XXH64_state_s for details. */ typedef struct XXH64_state_s XXH64_state_t; /* incomplete type */ XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void); XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr); XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state); XXH_PUBLIC_API XXH_errorcode XXH64_reset (XXH64_state_t* statePtr, XXH64_hash_t seed); XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length); XXH_PUBLIC_API XXH64_hash_t XXH64_digest (const XXH64_state_t* statePtr); /******* Canonical representation *******/ typedef struct { unsigned char digest[sizeof(XXH64_hash_t)]; } XXH64_canonical_t; XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash); XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src); /*! * @} * ************************************************************************ * @defgroup xxh3_family XXH3 family * @ingroup public * @{ * * XXH3 is a more recent hash algorithm featuring: * - Improved speed for both small and large inputs * - True 64-bit and 128-bit outputs * - SIMD acceleration * - Improved 32-bit viability * * Speed analysis methodology is explained here: * * https://fastcompression.blogspot.com/2019/03/presenting-xxh3.html * * Compared to XXH64, expect XXH3 to run approximately * ~2x faster on large inputs and >3x faster on small ones, * exact differences vary depending on platform. * * XXH3's speed benefits greatly from SIMD and 64-bit arithmetic, * but does not require it. * Any 32-bit and 64-bit targets that can run XXH32 smoothly * can run XXH3 at competitive speeds, even without vector support. * Further details are explained in the implementation. * * Optimized implementations are provided for AVX512, AVX2, SSE2, NEON, POWER8, * ZVector and scalar targets. This can be controlled via the XXH_VECTOR macro. * * XXH3 implementation is portable: * it has a generic C90 formulation that can be compiled on any platform, * all implementations generage exactly the same hash value on all platforms. * Starting from v0.8.0, it's also labelled "stable", meaning that * any future version will also generate the same hash value. * * XXH3 offers 2 variants, _64bits and _128bits. * * When only 64 bits are needed, prefer invoking the _64bits variant, as it * reduces the amount of mixing, resulting in faster speed on small inputs. * It's also generally simpler to manipulate a scalar return type than a struct. * * The API supports one-shot hashing, streaming mode, and custom secrets. */ /*-********************************************************************** * XXH3 64-bit variant ************************************************************************/ /* XXH3_64bits(): * default 64-bit variant, using default secret and default seed of 0. * It's the fastest variant. */ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits(const void* data, size_t len); /* * XXH3_64bits_withSeed(): * This variant generates a custom secret on the fly * based on default secret altered using the `seed` value. * While this operation is decently fast, note that it's not completely free. * Note: seed==0 produces the same results as XXH3_64bits(). */ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSeed(const void* data, size_t len, XXH64_hash_t seed); /*! * The bare minimum size for a custom secret. * * @see * XXH3_64bits_withSecret(), XXH3_64bits_reset_withSecret(), * XXH3_128bits_withSecret(), XXH3_128bits_reset_withSecret(). */ #define XXH3_SECRET_SIZE_MIN 136 /* * XXH3_64bits_withSecret(): * It's possible to provide any blob of bytes as a "secret" to generate the hash. * This makes it more difficult for an external actor to prepare an intentional collision. * The main condition is that secretSize *must* be large enough (>= XXH3_SECRET_SIZE_MIN). * However, the quality of produced hash values depends on secret's entropy. * Technically, the secret must look like a bunch of random bytes. * Avoid "trivial" or structured data such as repeated sequences or a text document. * Whenever unsure about the "randomness" of the blob of bytes, * consider relabelling it as a "custom seed" instead, * and employ "XXH3_generateSecret()" (see below) * to generate a high entropy secret derived from the custom seed. */ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSecret(const void* data, size_t len, const void* secret, size_t secretSize); /******* Streaming *******/ /* * Streaming requires state maintenance. * This operation costs memory and CPU. * As a consequence, streaming is slower than one-shot hashing. * For better performance, prefer one-shot functions whenever applicable. */ /*! * @brief The state struct for the XXH3 streaming API. * * @see XXH3_state_s for details. */ typedef struct XXH3_state_s XXH3_state_t; XXH_PUBLIC_API XXH3_state_t* XXH3_createState(void); XXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr); XXH_PUBLIC_API void XXH3_copyState(XXH3_state_t* dst_state, const XXH3_state_t* src_state); /* * XXH3_64bits_reset(): * Initialize with default parameters. * digest will be equivalent to `XXH3_64bits()`. */ XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset(XXH3_state_t* statePtr); /* * XXH3_64bits_reset_withSeed(): * Generate a custom secret from `seed`, and store it into `statePtr`. * digest will be equivalent to `XXH3_64bits_withSeed()`. */ XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed); /* * XXH3_64bits_reset_withSecret(): * `secret` is referenced, it _must outlive_ the hash streaming session. * Similar to one-shot API, `secretSize` must be >= `XXH3_SECRET_SIZE_MIN`, * and the quality of produced hash values depends on secret's entropy * (secret's content should look like a bunch of random bytes). * When in doubt about the randomness of a candidate `secret`, * consider employing `XXH3_generateSecret()` instead (see below). */ XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize); XXH_PUBLIC_API XXH_errorcode XXH3_64bits_update (XXH3_state_t* statePtr, const void* input, size_t length); XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (const XXH3_state_t* statePtr); /* note : canonical representation of XXH3 is the same as XXH64 * since they both produce XXH64_hash_t values */ /*-********************************************************************** * XXH3 128-bit variant ************************************************************************/ /*! * @brief The return value from 128-bit hashes. * * Stored in little endian order, although the fields themselves are in native * endianness. */ typedef struct { XXH64_hash_t low64; /*!< `value & 0xFFFFFFFFFFFFFFFF` */ XXH64_hash_t high64; /*!< `value >> 64` */ } XXH128_hash_t; XXH_PUBLIC_API XXH128_hash_t XXH3_128bits(const void* data, size_t len); XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSeed(const void* data, size_t len, XXH64_hash_t seed); XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSecret(const void* data, size_t len, const void* secret, size_t secretSize); /******* Streaming *******/ /* * Streaming requires state maintenance. * This operation costs memory and CPU. * As a consequence, streaming is slower than one-shot hashing. * For better performance, prefer one-shot functions whenever applicable. * * XXH3_128bits uses the same XXH3_state_t as XXH3_64bits(). * Use already declared XXH3_createState() and XXH3_freeState(). * * All reset and streaming functions have same meaning as their 64-bit counterpart. */ XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset(XXH3_state_t* statePtr); XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed); XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize); XXH_PUBLIC_API XXH_errorcode XXH3_128bits_update (XXH3_state_t* statePtr, const void* input, size_t length); XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (const XXH3_state_t* statePtr); /* Following helper functions make it possible to compare XXH128_hast_t values. * Since XXH128_hash_t is a structure, this capability is not offered by the language. * Note: For better performance, these functions can be inlined using XXH_INLINE_ALL */ /*! * XXH128_isEqual(): * Return: 1 if `h1` and `h2` are equal, 0 if they are not. */ XXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2); /*! * XXH128_cmp(): * * This comparator is compatible with stdlib's `qsort()`/`bsearch()`. * * return: >0 if *h128_1 > *h128_2 * =0 if *h128_1 == *h128_2 * <0 if *h128_1 < *h128_2 */ XXH_PUBLIC_API int XXH128_cmp(const void* h128_1, const void* h128_2); /******* Canonical representation *******/ typedef struct { unsigned char digest[sizeof(XXH128_hash_t)]; } XXH128_canonical_t; XXH_PUBLIC_API void XXH128_canonicalFromHash(XXH128_canonical_t* dst, XXH128_hash_t hash); XXH_PUBLIC_API XXH128_hash_t XXH128_hashFromCanonical(const XXH128_canonical_t* src); #endif /* XXH_NO_LONG_LONG */ /*! * @} */ #endif /* XXHASH_H_5627135585666179 */ #if defined(XXH_STATIC_LINKING_ONLY) && !defined(XXHASH_H_STATIC_13879238742) #define XXHASH_H_STATIC_13879238742 /* **************************************************************************** * This section contains declarations which are not guaranteed to remain stable. * They may change in future versions, becoming incompatible with a different * version of the library. * These declarations should only be used with static linking. * Never use them in association with dynamic linking! ***************************************************************************** */ /* * These definitions are only present to allow static allocation * of XXH states, on stack or in a struct, for example. * Never **ever** access their members directly. */ /*! * @internal * @brief Structure for XXH32 streaming API. * * @note This is only defined when @ref XXH_STATIC_LINKING_ONLY, * @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined. Otherwise it is * an opaque type. This allows fields to safely be changed. * * Typedef'd to @ref XXH32_state_t. * Do not access the members of this struct directly. * @see XXH64_state_s, XXH3_state_s */ struct XXH32_state_s { XXH32_hash_t total_len_32; /*!< Total length hashed, modulo 2^32 */ XXH32_hash_t large_len; /*!< Whether the hash is >= 16 (handles @ref total_len_32 overflow) */ XXH32_hash_t v1; /*!< First accumulator lane */ XXH32_hash_t v2; /*!< Second accumulator lane */ XXH32_hash_t v3; /*!< Third accumulator lane */ XXH32_hash_t v4; /*!< Fourth accumulator lane */ XXH32_hash_t mem32[4]; /*!< Internal buffer for partial reads. Treated as unsigned char[16]. */ XXH32_hash_t memsize; /*!< Amount of data in @ref mem32 */ XXH32_hash_t reserved; /*!< Reserved field. Do not read or write to it, it may be removed. */ }; /* typedef'd to XXH32_state_t */ #ifndef XXH_NO_LONG_LONG /* defined when there is no 64-bit support */ /*! * @internal * @brief Structure for XXH64 streaming API. * * @note This is only defined when @ref XXH_STATIC_LINKING_ONLY, * @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined. Otherwise it is * an opaque type. This allows fields to safely be changed. * * Typedef'd to @ref XXH64_state_t. * Do not access the members of this struct directly. * @see XXH32_state_s, XXH3_state_s */ struct XXH64_state_s { XXH64_hash_t total_len; /*!< Total length hashed. This is always 64-bit. */ XXH64_hash_t v1; /*!< First accumulator lane */ XXH64_hash_t v2; /*!< Second accumulator lane */ XXH64_hash_t v3; /*!< Third accumulator lane */ XXH64_hash_t v4; /*!< Fourth accumulator lane */ XXH64_hash_t mem64[4]; /*!< Internal buffer for partial reads. Treated as unsigned char[32]. */ XXH32_hash_t memsize; /*!< Amount of data in @ref mem64 */ XXH32_hash_t reserved32; /*!< Reserved field, needed for padding anyways*/ XXH64_hash_t reserved64; /*!< Reserved field. Do not read or write to it, it may be removed. */ }; /* typedef'd to XXH64_state_t */ #if defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) /* C11+ */ # include # define XXH_ALIGN(n) alignas(n) #elif defined(__GNUC__) # define XXH_ALIGN(n) __attribute__ ((aligned(n))) #elif defined(_MSC_VER) # define XXH_ALIGN(n) __declspec(align(n)) #else # define XXH_ALIGN(n) /* disabled */ #endif /* Old GCC versions only accept the attribute after the type in structures. */ #if !(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) /* C11+ */ \ && defined(__GNUC__) # define XXH_ALIGN_MEMBER(align, type) type XXH_ALIGN(align) #else # define XXH_ALIGN_MEMBER(align, type) XXH_ALIGN(align) type #endif /*! * @brief The size of the internal XXH3 buffer. * * This is the optimal update size for incremental hashing. * * @see XXH3_64b_update(), XXH3_128b_update(). */ #define XXH3_INTERNALBUFFER_SIZE 256 /*! * @brief Default size of the secret buffer (and @ref XXH3_kSecret). * * This is the size used in @ref XXH3_kSecret and the seeded functions. * * Not to be confused with @ref XXH3_SECRET_SIZE_MIN. */ #define XXH3_SECRET_DEFAULT_SIZE 192 /*! * @internal * @brief Structure for XXH3 streaming API. * * @note This is only defined when @ref XXH_STATIC_LINKING_ONLY, * @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined. Otherwise it is * an opaque type. This allows fields to safely be changed. * * @note **This structure has a strict alignment requirement of 64 bytes.** Do * not allocate this with `malloc()` or `new`, it will not be sufficiently * aligned. Use @ref XXH3_createState() and @ref XXH3_freeState(), or stack * allocation. * * Typedef'd to @ref XXH3_state_t. * Do not access the members of this struct directly. * * @see XXH3_INITSTATE() for stack initialization. * @see XXH3_createState(), XXH3_freeState(). * @see XXH32_state_s, XXH64_state_s */ struct XXH3_state_s { XXH_ALIGN_MEMBER(64, XXH64_hash_t acc[8]); /*!< The 8 accumulators. Similar to `vN` in @ref XXH32_state_s::v1 and @ref XXH64_state_s */ XXH_ALIGN_MEMBER(64, unsigned char customSecret[XXH3_SECRET_DEFAULT_SIZE]); /*!< Used to store a custom secret generated from a seed. */ XXH_ALIGN_MEMBER(64, unsigned char buffer[XXH3_INTERNALBUFFER_SIZE]); /*!< The internal buffer. @see XXH32_state_s::mem32 */ XXH32_hash_t bufferedSize; /*!< The amount of memory in @ref buffer, @see XXH32_state_s::memsize */ XXH32_hash_t reserved32; /*!< Reserved field. Needed for padding on 64-bit. */ size_t nbStripesSoFar; /*!< Number or stripes processed. */ XXH64_hash_t totalLen; /*!< Total length hashed. 64-bit even on 32-bit targets. */ size_t nbStripesPerBlock; /*!< Number of stripes per block. */ size_t secretLimit; /*!< Size of @ref customSecret or @ref extSecret */ XXH64_hash_t seed; /*!< Seed for _withSeed variants. Must be zero otherwise, @see XXH3_INITSTATE() */ XXH64_hash_t reserved64; /*!< Reserved field. */ const unsigned char* extSecret; /*!< Reference to an external secret for the _withSecret variants, NULL * for other variants. */ /* note: there may be some padding at the end due to alignment on 64 bytes */ }; /* typedef'd to XXH3_state_t */ #undef XXH_ALIGN_MEMBER /*! * @brief Initializes a stack-allocated `XXH3_state_s`. * * When the @ref XXH3_state_t structure is merely emplaced on stack, * it should be initialized with XXH3_INITSTATE() or a memset() * in case its first reset uses XXH3_NNbits_reset_withSeed(). * This init can be omitted if the first reset uses default or _withSecret mode. * This operation isn't necessary when the state is created with XXH3_createState(). * Note that this doesn't prepare the state for a streaming operation, * it's still necessary to use XXH3_NNbits_reset*() afterwards. */ #define XXH3_INITSTATE(XXH3_state_ptr) { (XXH3_state_ptr)->seed = 0; } /* === Experimental API === */ /* Symbols defined below must be considered tied to a specific library version. */ /* * XXH3_generateSecret(): * * Derive a high-entropy secret from any user-defined content, named customSeed. * The generated secret can be used in combination with `*_withSecret()` functions. * The `_withSecret()` variants are useful to provide a higher level of protection than 64-bit seed, * as it becomes much more difficult for an external actor to guess how to impact the calculation logic. * * The function accepts as input a custom seed of any length and any content, * and derives from it a high-entropy secret of length XXH3_SECRET_DEFAULT_SIZE * into an already allocated buffer secretBuffer. * The generated secret is _always_ XXH_SECRET_DEFAULT_SIZE bytes long. * * The generated secret can then be used with any `*_withSecret()` variant. * Functions `XXH3_128bits_withSecret()`, `XXH3_64bits_withSecret()`, * `XXH3_128bits_reset_withSecret()` and `XXH3_64bits_reset_withSecret()` * are part of this list. They all accept a `secret` parameter * which must be very long for implementation reasons (>= XXH3_SECRET_SIZE_MIN) * _and_ feature very high entropy (consist of random-looking bytes). * These conditions can be a high bar to meet, so * this function can be used to generate a secret of proper quality. * * customSeed can be anything. It can have any size, even small ones, * and its content can be anything, even stupidly "low entropy" source such as a bunch of zeroes. * The resulting `secret` will nonetheless provide all expected qualities. * * Supplying NULL as the customSeed copies the default secret into `secretBuffer`. * When customSeedSize > 0, supplying NULL as customSeed is undefined behavior. */ XXH_PUBLIC_API void XXH3_generateSecret(void* secretBuffer, const void* customSeed, size_t customSeedSize); /* simple short-cut to pre-selected XXH3_128bits variant */ XXH_PUBLIC_API XXH128_hash_t XXH128(const void* data, size_t len, XXH64_hash_t seed); #endif /* XXH_NO_LONG_LONG */ #if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API) # define XXH_IMPLEMENTATION #endif #endif /* defined(XXH_STATIC_LINKING_ONLY) && !defined(XXHASH_H_STATIC_13879238742) */ /* ======================================================================== */ /* ======================================================================== */ /* ======================================================================== */ /*-********************************************************************** * xxHash implementation *-********************************************************************** * xxHash's implementation used to be hosted inside xxhash.c. * * However, inlining requires implementation to be visible to the compiler, * hence be included alongside the header. * Previously, implementation was hosted inside xxhash.c, * which was then #included when inlining was activated. * This construction created issues with a few build and install systems, * as it required xxhash.c to be stored in /include directory. * * xxHash implementation is now directly integrated within xxhash.h. * As a consequence, xxhash.c is no longer needed in /include. * * xxhash.c is still available and is still useful. * In a "normal" setup, when xxhash is not inlined, * xxhash.h only exposes the prototypes and public symbols, * while xxhash.c can be built into an object file xxhash.o * which can then be linked into the final binary. ************************************************************************/ #if ( defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API) \ || defined(XXH_IMPLEMENTATION) ) && !defined(XXH_IMPLEM_13a8737387) # define XXH_IMPLEM_13a8737387 /* ************************************* * Tuning parameters ***************************************/ /*! * @defgroup tuning Tuning parameters * @{ * * Various macros to control xxHash's behavior. */ #ifdef XXH_DOXYGEN /*! * @brief Define this to disable 64-bit code. * * Useful if only using the @ref xxh32_family and you have a strict C90 compiler. */ # define XXH_NO_LONG_LONG # undef XXH_NO_LONG_LONG /* don't actually */ /*! * @brief Controls how unaligned memory is accessed. * * By default, access to unaligned memory is controlled by `memcpy()`, which is * safe and portable. * * Unfortunately, on some target/compiler combinations, the generated assembly * is sub-optimal. * * The below switch allow selection of a different access method * in the search for improved performance. * * @par Possible options: * * - `XXH_FORCE_MEMORY_ACCESS=0` (default): `memcpy` * @par * Use `memcpy()`. Safe and portable. Note that most modern compilers will * eliminate the function call and treat it as an unaligned access. * * - `XXH_FORCE_MEMORY_ACCESS=1`: `__attribute__((packed))` * @par * Depends on compiler extensions and is therefore not portable. * This method is safe _if_ your compiler supports it, * and *generally* as fast or faster than `memcpy`. * * - `XXH_FORCE_MEMORY_ACCESS=2`: Direct cast * @par * Casts directly and dereferences. This method doesn't depend on the * compiler, but it violates the C standard as it directly dereferences an * unaligned pointer. It can generate buggy code on targets which do not * support unaligned memory accesses, but in some circumstances, it's the * only known way to get the most performance. * * - `XXH_FORCE_MEMORY_ACCESS=3`: Byteshift * @par * Also portable. This can generate the best code on old compilers which don't * inline small `memcpy()` calls, and it might also be faster on big-endian * systems which lack a native byteswap instruction. However, some compilers * will emit literal byteshifts even if the target supports unaligned access. * . * * @warning * Methods 1 and 2 rely on implementation-defined behavior. Use these with * care, as what works on one compiler/platform/optimization level may cause * another to read garbage data or even crash. * * See https://stackoverflow.com/a/32095106/646947 for details. * * Prefer these methods in priority order (0 > 3 > 1 > 2) */ # define XXH_FORCE_MEMORY_ACCESS 0 /*! * @def XXH_ACCEPT_NULL_INPUT_POINTER * @brief Whether to add explicit `NULL` checks. * * If the input pointer is `NULL` and the length is non-zero, xxHash's default * behavior is to dereference it, triggering a segfault. * * When this macro is enabled, xxHash actively checks the input for a null pointer. * If it is, the result for null input pointers is the same as a zero-length input. */ # define XXH_ACCEPT_NULL_INPUT_POINTER 0 /*! * @def XXH_FORCE_ALIGN_CHECK * @brief If defined to non-zero, adds a special path for aligned inputs (XXH32() * and XXH64() only). * * This is an important performance trick for architectures without decent * unaligned memory access performance. * * It checks for input alignment, and when conditions are met, uses a "fast * path" employing direct 32-bit/64-bit reads, resulting in _dramatically * faster_ read speed. * * The check costs one initial branch per hash, which is generally negligible, * but not zero. * * Moreover, it's not useful to generate an additional code path if memory * access uses the same instruction for both aligned and unaligned * addresses (e.g. x86 and aarch64). * * In these cases, the alignment check can be removed by setting this macro to 0. * Then the code will always use unaligned memory access. * Align check is automatically disabled on x86, x64 & arm64, * which are platforms known to offer good unaligned memory accesses performance. * * This option does not affect XXH3 (only XXH32 and XXH64). */ # define XXH_FORCE_ALIGN_CHECK 0 /*! * @def XXH_NO_INLINE_HINTS * @brief When non-zero, sets all functions to `static`. * * By default, xxHash tries to force the compiler to inline almost all internal * functions. * * This can usually improve performance due to reduced jumping and improved * constant folding, but significantly increases the size of the binary which * might not be favorable. * * Additionally, sometimes the forced inlining can be detrimental to performance, * depending on the architecture. * * XXH_NO_INLINE_HINTS marks all internal functions as static, giving the * compiler full control on whether to inline or not. * * When not optimizing (-O0), optimizing for size (-Os, -Oz), or using * -fno-inline with GCC or Clang, this will automatically be defined. */ # define XXH_NO_INLINE_HINTS 0 /*! * @def XXH_REROLL * @brief Whether to reroll `XXH32_finalize` and `XXH64_finalize`. * * For performance, `XXH32_finalize` and `XXH64_finalize` use an unrolled loop * in the form of a switch statement. * * This is not always desirable, as it generates larger code, and depending on * the architecture, may even be slower * * This is automatically defined with `-Os`/`-Oz` on GCC and Clang. */ # define XXH_REROLL 0 /*! * @internal * @brief Redefines old internal names. * * For compatibility with code that uses xxHash's internals before the names * were changed to improve namespacing. There is no other reason to use this. */ # define XXH_OLD_NAMES # undef XXH_OLD_NAMES /* don't actually use, it is ugly. */ #endif /* XXH_DOXYGEN */ /*! * @} */ #ifndef XXH_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */ /* prefer __packed__ structures (method 1) for gcc on armv7 and armv8 */ # if !defined(__clang__) && ( \ (defined(__INTEL_COMPILER) && !defined(_WIN32)) || \ (defined(__GNUC__) && (defined(__ARM_ARCH) && __ARM_ARCH >= 7)) ) # define XXH_FORCE_MEMORY_ACCESS 1 # endif #endif #ifndef XXH_ACCEPT_NULL_INPUT_POINTER /* can be defined externally */ # define XXH_ACCEPT_NULL_INPUT_POINTER 0 #endif #ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */ # if defined(__i386) || defined(__x86_64__) || defined(__aarch64__) \ || defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM64) /* visual */ # define XXH_FORCE_ALIGN_CHECK 0 # else # define XXH_FORCE_ALIGN_CHECK 1 # endif #endif #ifndef XXH_NO_INLINE_HINTS # if defined(__OPTIMIZE_SIZE__) /* -Os, -Oz */ \ || defined(__NO_INLINE__) /* -O0, -fno-inline */ # define XXH_NO_INLINE_HINTS 1 # else # define XXH_NO_INLINE_HINTS 0 # endif #endif #ifndef XXH_REROLL # if defined(__OPTIMIZE_SIZE__) # define XXH_REROLL 1 # else # define XXH_REROLL 0 # endif #endif /*! * @defgroup impl Implementation * @{ */ /* ************************************* * Includes & Memory related functions ***************************************/ /* * Modify the local functions below should you wish to use * different memory routines for malloc() and free() */ #include /*! * @internal * @brief Modify this function to use a different routine than malloc(). */ static void* XXH_malloc(size_t s) { return malloc(s); } /*! * @internal * @brief Modify this function to use a different routine than free(). */ static void XXH_free(void* p) { free(p); } #include /*! * @internal * @brief Modify this function to use a different routine than memcpy(). */ static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); } #include /* ULLONG_MAX */ /* ************************************* * Compiler Specific Options ***************************************/ #ifdef _MSC_VER /* Visual Studio warning fix */ # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ #endif #if XXH_NO_INLINE_HINTS /* disable inlining hints */ # if defined(__GNUC__) # define XXH_FORCE_INLINE static __attribute__((unused)) # else # define XXH_FORCE_INLINE static # endif # define XXH_NO_INLINE static /* enable inlining hints */ #elif defined(_MSC_VER) /* Visual Studio */ # define XXH_FORCE_INLINE static __forceinline # define XXH_NO_INLINE static __declspec(noinline) #elif defined(__GNUC__) # define XXH_FORCE_INLINE static __inline__ __attribute__((always_inline, unused)) # define XXH_NO_INLINE static __attribute__((noinline)) #elif defined (__cplusplus) \ || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) /* C99 */ # define XXH_FORCE_INLINE static inline # define XXH_NO_INLINE static #else # define XXH_FORCE_INLINE static # define XXH_NO_INLINE static #endif /* ************************************* * Debug ***************************************/ /*! * @ingroup tuning * @def XXH_DEBUGLEVEL * @brief Sets the debugging level. * * XXH_DEBUGLEVEL is expected to be defined externally, typically via the * compiler's command line options. The value must be a number. */ #ifndef XXH_DEBUGLEVEL # ifdef DEBUGLEVEL /* backwards compat */ # define XXH_DEBUGLEVEL DEBUGLEVEL # else # define XXH_DEBUGLEVEL 0 # endif #endif #if (XXH_DEBUGLEVEL>=1) # include /* note: can still be disabled with NDEBUG */ # define XXH_ASSERT(c) assert(c) #else # define XXH_ASSERT(c) ((void)0) #endif /* note: use after variable declarations */ #define XXH_STATIC_ASSERT(c) do { enum { XXH_sa = 1/(int)(!!(c)) }; } while (0) /*! * @internal * @def XXH_COMPILER_GUARD(var) * @brief Used to prevent unwanted optimizations for @p var. * * It uses an empty GCC inline assembly statement with a register constraint * which forces @p var into a general purpose register (eg eax, ebx, ecx * on x86) and marks it as modified. * * This is used in a few places to avoid unwanted autovectorization (e.g. * XXH32_round()). All vectorization we want is explicit via intrinsics, * and _usually_ isn't wanted elsewhere. * * We also use it to prevent unwanted constant folding for AArch64 in * XXH3_initCustomSecret_scalar(). */ #ifdef __GNUC__ # define XXH_COMPILER_GUARD(var) __asm__ __volatile__("" : "+r" (var)) #else # define XXH_COMPILER_GUARD(var) ((void)0) #endif /* ************************************* * Basic Types ***************************************/ #if !defined (__VMS) \ && (defined (__cplusplus) \ || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) # include typedef uint8_t xxh_u8; #else typedef unsigned char xxh_u8; #endif typedef XXH32_hash_t xxh_u32; #ifdef XXH_OLD_NAMES # define BYTE xxh_u8 # define U8 xxh_u8 # define U32 xxh_u32 #endif /* *** Memory access *** */ /*! * @internal * @fn xxh_u32 XXH_read32(const void* ptr) * @brief Reads an unaligned 32-bit integer from @p ptr in native endianness. * * Affected by @ref XXH_FORCE_MEMORY_ACCESS. * * @param ptr The pointer to read from. * @return The 32-bit native endian integer from the bytes at @p ptr. */ /*! * @internal * @fn xxh_u32 XXH_readLE32(const void* ptr) * @brief Reads an unaligned 32-bit little endian integer from @p ptr. * * Affected by @ref XXH_FORCE_MEMORY_ACCESS. * * @param ptr The pointer to read from. * @return The 32-bit little endian integer from the bytes at @p ptr. */ /*! * @internal * @fn xxh_u32 XXH_readBE32(const void* ptr) * @brief Reads an unaligned 32-bit big endian integer from @p ptr. * * Affected by @ref XXH_FORCE_MEMORY_ACCESS. * * @param ptr The pointer to read from. * @return The 32-bit big endian integer from the bytes at @p ptr. */ /*! * @internal * @fn xxh_u32 XXH_readLE32_align(const void* ptr, XXH_alignment align) * @brief Like @ref XXH_readLE32(), but has an option for aligned reads. * * Affected by @ref XXH_FORCE_MEMORY_ACCESS. * Note that when @ref XXH_FORCE_ALIGN_CHECK == 0, the @p align parameter is * always @ref XXH_alignment::XXH_unaligned. * * @param ptr The pointer to read from. * @param align Whether @p ptr is aligned. * @pre * If @p align == @ref XXH_alignment::XXH_aligned, @p ptr must be 4 byte * aligned. * @return The 32-bit little endian integer from the bytes at @p ptr. */ #if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3)) /* * Manual byteshift. Best for old compilers which don't inline memcpy. * We actually directly use XXH_readLE32 and XXH_readBE32. */ #elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2)) /* * Force direct memory access. Only works on CPU which support unaligned memory * access in hardware. */ static xxh_u32 XXH_read32(const void* memPtr) { return *(const xxh_u32*) memPtr; } #elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1)) /* * __pack instructions are safer but compiler specific, hence potentially * problematic for some compilers. * * Currently only defined for GCC and ICC. */ #ifdef XXH_OLD_NAMES typedef union { xxh_u32 u32; } __attribute__((packed)) unalign; #endif static xxh_u32 XXH_read32(const void* ptr) { typedef union { xxh_u32 u32; } __attribute__((packed)) xxh_unalign; return ((const xxh_unalign*)ptr)->u32; } #else /* * Portable and safe solution. Generally efficient. * see: https://stackoverflow.com/a/32095106/646947 */ static xxh_u32 XXH_read32(const void* memPtr) { xxh_u32 val; memcpy(&val, memPtr, sizeof(val)); return val; } #endif /* XXH_FORCE_DIRECT_MEMORY_ACCESS */ /* *** Endianness *** */ typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess; /*! * @ingroup tuning * @def XXH_CPU_LITTLE_ENDIAN * @brief Whether the target is little endian. * * Defined to 1 if the target is little endian, or 0 if it is big endian. * It can be defined externally, for example on the compiler command line. * * If it is not defined, a runtime check (which is usually constant folded) * is used instead. * * @note * This is not necessarily defined to an integer constant. * * @see XXH_isLittleEndian() for the runtime check. */ #ifndef XXH_CPU_LITTLE_ENDIAN /* * Try to detect endianness automatically, to avoid the nonstandard behavior * in `XXH_isLittleEndian()` */ # if defined(_WIN32) /* Windows is always little endian */ \ || defined(__LITTLE_ENDIAN__) \ || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) # define XXH_CPU_LITTLE_ENDIAN 1 # elif defined(__BIG_ENDIAN__) \ || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) # define XXH_CPU_LITTLE_ENDIAN 0 # else /*! * @internal * @brief Runtime check for @ref XXH_CPU_LITTLE_ENDIAN. * * Most compilers will constant fold this. */ static int XXH_isLittleEndian(void) { /* * Portable and well-defined behavior. * Don't use static: it is detrimental to performance. */ const union { xxh_u32 u; xxh_u8 c[4]; } one = { 1 }; return one.c[0]; } # define XXH_CPU_LITTLE_ENDIAN XXH_isLittleEndian() # endif #endif /* **************************************** * Compiler-specific Functions and Macros ******************************************/ #define XXH_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) #ifdef __has_builtin # define XXH_HAS_BUILTIN(x) __has_builtin(x) #else # define XXH_HAS_BUILTIN(x) 0 #endif /*! * @internal * @def XXH_rotl32(x,r) * @brief 32-bit rotate left. * * @param x The 32-bit integer to be rotated. * @param r The number of bits to rotate. * @pre * @p r > 0 && @p r < 32 * @note * @p x and @p r may be evaluated multiple times. * @return The rotated result. */ #if !defined(NO_CLANG_BUILTIN) && XXH_HAS_BUILTIN(__builtin_rotateleft32) \ && XXH_HAS_BUILTIN(__builtin_rotateleft64) # define XXH_rotl32 __builtin_rotateleft32 # define XXH_rotl64 __builtin_rotateleft64 /* Note: although _rotl exists for minGW (GCC under windows), performance seems poor */ #elif defined(_MSC_VER) # define XXH_rotl32(x,r) _rotl(x,r) # define XXH_rotl64(x,r) _rotl64(x,r) #else # define XXH_rotl32(x,r) (((x) << (r)) | ((x) >> (32 - (r)))) # define XXH_rotl64(x,r) (((x) << (r)) | ((x) >> (64 - (r)))) #endif /*! * @internal * @fn xxh_u32 XXH_swap32(xxh_u32 x) * @brief A 32-bit byteswap. * * @param x The 32-bit integer to byteswap. * @return @p x, byteswapped. */ #if defined(_MSC_VER) /* Visual Studio */ # define XXH_swap32 _byteswap_ulong #elif XXH_GCC_VERSION >= 403 # define XXH_swap32 __builtin_bswap32 #else static xxh_u32 XXH_swap32 (xxh_u32 x) { return ((x << 24) & 0xff000000 ) | ((x << 8) & 0x00ff0000 ) | ((x >> 8) & 0x0000ff00 ) | ((x >> 24) & 0x000000ff ); } #endif /* *************************** * Memory reads *****************************/ /*! * @internal * @brief Enum to indicate whether a pointer is aligned. */ typedef enum { XXH_aligned, /*!< Aligned */ XXH_unaligned /*!< Possibly unaligned */ } XXH_alignment; /* * XXH_FORCE_MEMORY_ACCESS==3 is an endian-independent byteshift load. * * This is ideal for older compilers which don't inline memcpy. */ #if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3)) XXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* memPtr) { const xxh_u8* bytePtr = (const xxh_u8 *)memPtr; return bytePtr[0] | ((xxh_u32)bytePtr[1] << 8) | ((xxh_u32)bytePtr[2] << 16) | ((xxh_u32)bytePtr[3] << 24); } XXH_FORCE_INLINE xxh_u32 XXH_readBE32(const void* memPtr) { const xxh_u8* bytePtr = (const xxh_u8 *)memPtr; return bytePtr[3] | ((xxh_u32)bytePtr[2] << 8) | ((xxh_u32)bytePtr[1] << 16) | ((xxh_u32)bytePtr[0] << 24); } #else XXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* ptr) { return XXH_CPU_LITTLE_ENDIAN ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr)); } static xxh_u32 XXH_readBE32(const void* ptr) { return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr); } #endif XXH_FORCE_INLINE xxh_u32 XXH_readLE32_align(const void* ptr, XXH_alignment align) { if (align==XXH_unaligned) { return XXH_readLE32(ptr); } else { return XXH_CPU_LITTLE_ENDIAN ? *(const xxh_u32*)ptr : XXH_swap32(*(const xxh_u32*)ptr); } } /* ************************************* * Misc ***************************************/ /*! @ingroup public */ XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; } /* ******************************************************************* * 32-bit hash functions *********************************************************************/ /*! * @} * @defgroup xxh32_impl XXH32 implementation * @ingroup impl * @{ */ /* #define instead of static const, to be used as initializers */ #define XXH_PRIME32_1 0x9E3779B1U /*!< 0b10011110001101110111100110110001 */ #define XXH_PRIME32_2 0x85EBCA77U /*!< 0b10000101111010111100101001110111 */ #define XXH_PRIME32_3 0xC2B2AE3DU /*!< 0b11000010101100101010111000111101 */ #define XXH_PRIME32_4 0x27D4EB2FU /*!< 0b00100111110101001110101100101111 */ #define XXH_PRIME32_5 0x165667B1U /*!< 0b00010110010101100110011110110001 */ #ifdef XXH_OLD_NAMES # define PRIME32_1 XXH_PRIME32_1 # define PRIME32_2 XXH_PRIME32_2 # define PRIME32_3 XXH_PRIME32_3 # define PRIME32_4 XXH_PRIME32_4 # define PRIME32_5 XXH_PRIME32_5 #endif /*! * @internal * @brief Normal stripe processing routine. * * This shuffles the bits so that any bit from @p input impacts several bits in * @p acc. * * @param acc The accumulator lane. * @param input The stripe of input to mix. * @return The mixed accumulator lane. */ static xxh_u32 XXH32_round(xxh_u32 acc, xxh_u32 input) { acc += input * XXH_PRIME32_2; acc = XXH_rotl32(acc, 13); acc *= XXH_PRIME32_1; #if (defined(__SSE4_1__) || defined(__aarch64__)) && !defined(XXH_ENABLE_AUTOVECTORIZE) /* * UGLY HACK: * A compiler fence is the only thing that prevents GCC and Clang from * autovectorizing the XXH32 loop (pragmas and attributes don't work for some * reason) without globally disabling SSE4.1. * * The reason we want to avoid vectorization is because despite working on * 4 integers at a time, there are multiple factors slowing XXH32 down on * SSE4: * - There's a ridiculous amount of lag from pmulld (10 cycles of latency on * newer chips!) making it slightly slower to multiply four integers at * once compared to four integers independently. Even when pmulld was * fastest, Sandy/Ivy Bridge, it is still not worth it to go into SSE * just to multiply unless doing a long operation. * * - Four instructions are required to rotate, * movqda tmp, v // not required with VEX encoding * pslld tmp, 13 // tmp <<= 13 * psrld v, 19 // x >>= 19 * por v, tmp // x |= tmp * compared to one for scalar: * roll v, 13 // reliably fast across the board * shldl v, v, 13 // Sandy Bridge and later prefer this for some reason * * - Instruction level parallelism is actually more beneficial here because * the SIMD actually serializes this operation: While v1 is rotating, v2 * can load data, while v3 can multiply. SSE forces them to operate * together. * * This is also enabled on AArch64, as Clang autovectorizes it incorrectly * and it is pointless writing a NEON implementation that is basically the * same speed as scalar for XXH32. */ XXH_COMPILER_GUARD(acc); #endif return acc; } /*! * @internal * @brief Mixes all bits to finalize the hash. * * The final mix ensures that all input bits have a chance to impact any bit in * the output digest, resulting in an unbiased distribution. * * @param h32 The hash to avalanche. * @return The avalanched hash. */ static xxh_u32 XXH32_avalanche(xxh_u32 h32) { h32 ^= h32 >> 15; h32 *= XXH_PRIME32_2; h32 ^= h32 >> 13; h32 *= XXH_PRIME32_3; h32 ^= h32 >> 16; return(h32); } #define XXH_get32bits(p) XXH_readLE32_align(p, align) /*! * @internal * @brief Processes the last 0-15 bytes of @p ptr. * * There may be up to 15 bytes remaining to consume from the input. * This final stage will digest them to ensure that all input bytes are present * in the final mix. * * @param h32 The hash to finalize. * @param ptr The pointer to the remaining input. * @param len The remaining length, modulo 16. * @param align Whether @p ptr is aligned. * @return The finalized hash. */ static xxh_u32 XXH32_finalize(xxh_u32 h32, const xxh_u8* ptr, size_t len, XXH_alignment align) { #define XXH_PROCESS1 do { \ h32 += (*ptr++) * XXH_PRIME32_5; \ h32 = XXH_rotl32(h32, 11) * XXH_PRIME32_1; \ } while (0) #define XXH_PROCESS4 do { \ h32 += XXH_get32bits(ptr) * XXH_PRIME32_3; \ ptr += 4; \ h32 = XXH_rotl32(h32, 17) * XXH_PRIME32_4; \ } while (0) /* Compact rerolled version */ if (XXH_REROLL) { len &= 15; while (len >= 4) { XXH_PROCESS4; len -= 4; } while (len > 0) { XXH_PROCESS1; --len; } return XXH32_avalanche(h32); } else { switch(len&15) /* or switch(bEnd - p) */ { case 12: XXH_PROCESS4; /* fallthrough */ case 8: XXH_PROCESS4; /* fallthrough */ case 4: XXH_PROCESS4; return XXH32_avalanche(h32); case 13: XXH_PROCESS4; /* fallthrough */ case 9: XXH_PROCESS4; /* fallthrough */ case 5: XXH_PROCESS4; XXH_PROCESS1; return XXH32_avalanche(h32); case 14: XXH_PROCESS4; /* fallthrough */ case 10: XXH_PROCESS4; /* fallthrough */ case 6: XXH_PROCESS4; XXH_PROCESS1; XXH_PROCESS1; return XXH32_avalanche(h32); case 15: XXH_PROCESS4; /* fallthrough */ case 11: XXH_PROCESS4; /* fallthrough */ case 7: XXH_PROCESS4; /* fallthrough */ case 3: XXH_PROCESS1; /* fallthrough */ case 2: XXH_PROCESS1; /* fallthrough */ case 1: XXH_PROCESS1; /* fallthrough */ case 0: return XXH32_avalanche(h32); } XXH_ASSERT(0); return h32; /* reaching this point is deemed impossible */ } } #ifdef XXH_OLD_NAMES # define PROCESS1 XXH_PROCESS1 # define PROCESS4 XXH_PROCESS4 #else # undef XXH_PROCESS1 # undef XXH_PROCESS4 #endif /*! * @internal * @brief The implementation for @ref XXH32(). * * @param input, len, seed Directly passed from @ref XXH32(). * @param align Whether @p input is aligned. * @return The calculated hash. */ XXH_FORCE_INLINE xxh_u32 XXH32_endian_align(const xxh_u8* input, size_t len, xxh_u32 seed, XXH_alignment align) { const xxh_u8* bEnd = input + len; xxh_u32 h32; #if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1) if (input==NULL) { len=0; bEnd=input=(const xxh_u8*)(size_t)16; } #endif if (len>=16) { const xxh_u8* const limit = bEnd - 15; xxh_u32 v1 = seed + XXH_PRIME32_1 + XXH_PRIME32_2; xxh_u32 v2 = seed + XXH_PRIME32_2; xxh_u32 v3 = seed + 0; xxh_u32 v4 = seed - XXH_PRIME32_1; do { v1 = XXH32_round(v1, XXH_get32bits(input)); input += 4; v2 = XXH32_round(v2, XXH_get32bits(input)); input += 4; v3 = XXH32_round(v3, XXH_get32bits(input)); input += 4; v4 = XXH32_round(v4, XXH_get32bits(input)); input += 4; } while (input < limit); h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18); } else { h32 = seed + XXH_PRIME32_5; } h32 += (xxh_u32)len; return XXH32_finalize(h32, input, len&15, align); } /*! @ingroup xxh32_family */ XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t len, XXH32_hash_t seed) { #if 0 /* Simple version, good for code maintenance, but unfortunately slow for small inputs */ XXH32_state_t state; XXH32_reset(&state, seed); XXH32_update(&state, (const xxh_u8*)input, len); return XXH32_digest(&state); #else if (XXH_FORCE_ALIGN_CHECK) { if ((((size_t)input) & 3) == 0) { /* Input is 4-bytes aligned, leverage the speed benefit */ return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_aligned); } } return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_unaligned); #endif } /******* Hash streaming *******/ /*! * @ingroup xxh32_family */ XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void) { return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t)); } /*! @ingroup xxh32_family */ XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr) { XXH_free(statePtr); return XXH_OK; } /*! @ingroup xxh32_family */ XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32_state_t* srcState) { memcpy(dstState, srcState, sizeof(*dstState)); } /*! @ingroup xxh32_family */ XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, XXH32_hash_t seed) { XXH32_state_t state; /* using a local state to memcpy() in order to avoid strict-aliasing warnings */ memset(&state, 0, sizeof(state)); state.v1 = seed + XXH_PRIME32_1 + XXH_PRIME32_2; state.v2 = seed + XXH_PRIME32_2; state.v3 = seed + 0; state.v4 = seed - XXH_PRIME32_1; /* do not write into reserved, planned to be removed in a future version */ memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved)); return XXH_OK; } /*! @ingroup xxh32_family */ XXH_PUBLIC_API XXH_errorcode XXH32_update(XXH32_state_t* state, const void* input, size_t len) { if (input==NULL) #if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1) return XXH_OK; #else return XXH_ERROR; #endif { const xxh_u8* p = (const xxh_u8*)input; const xxh_u8* const bEnd = p + len; state->total_len_32 += (XXH32_hash_t)len; state->large_len |= (XXH32_hash_t)((len>=16) | (state->total_len_32>=16)); if (state->memsize + len < 16) { /* fill in tmp buffer */ XXH_memcpy((xxh_u8*)(state->mem32) + state->memsize, input, len); state->memsize += (XXH32_hash_t)len; return XXH_OK; } if (state->memsize) { /* some data left from previous update */ XXH_memcpy((xxh_u8*)(state->mem32) + state->memsize, input, 16-state->memsize); { const xxh_u32* p32 = state->mem32; state->v1 = XXH32_round(state->v1, XXH_readLE32(p32)); p32++; state->v2 = XXH32_round(state->v2, XXH_readLE32(p32)); p32++; state->v3 = XXH32_round(state->v3, XXH_readLE32(p32)); p32++; state->v4 = XXH32_round(state->v4, XXH_readLE32(p32)); } p += 16-state->memsize; state->memsize = 0; } if (p <= bEnd-16) { const xxh_u8* const limit = bEnd - 16; xxh_u32 v1 = state->v1; xxh_u32 v2 = state->v2; xxh_u32 v3 = state->v3; xxh_u32 v4 = state->v4; do { v1 = XXH32_round(v1, XXH_readLE32(p)); p+=4; v2 = XXH32_round(v2, XXH_readLE32(p)); p+=4; v3 = XXH32_round(v3, XXH_readLE32(p)); p+=4; v4 = XXH32_round(v4, XXH_readLE32(p)); p+=4; } while (p<=limit); state->v1 = v1; state->v2 = v2; state->v3 = v3; state->v4 = v4; } if (p < bEnd) { XXH_memcpy(state->mem32, p, (size_t)(bEnd-p)); state->memsize = (unsigned)(bEnd-p); } } return XXH_OK; } /*! @ingroup xxh32_family */ XXH_PUBLIC_API XXH32_hash_t XXH32_digest(const XXH32_state_t* state) { xxh_u32 h32; if (state->large_len) { h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18); } else { h32 = state->v3 /* == seed */ + XXH_PRIME32_5; } h32 += state->total_len_32; return XXH32_finalize(h32, (const xxh_u8*)state->mem32, state->memsize, XXH_aligned); } /******* Canonical representation *******/ /*! * @ingroup xxh32_family * The default return values from XXH functions are unsigned 32 and 64 bit * integers. * * The canonical representation uses big endian convention, the same convention * as human-readable numbers (large digits first). * * This way, hash values can be written into a file or buffer, remaining * comparable across different systems. * * The following functions allow transformation of hash values to and from their * canonical format. */ XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash) { XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t)); if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash); memcpy(dst, &hash, sizeof(*dst)); } /*! @ingroup xxh32_family */ XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src) { return XXH_readBE32(src); } #ifndef XXH_NO_LONG_LONG /* ******************************************************************* * 64-bit hash functions *********************************************************************/ /*! * @} * @ingroup impl * @{ */ /******* Memory access *******/ typedef XXH64_hash_t xxh_u64; #ifdef XXH_OLD_NAMES # define U64 xxh_u64 #endif #if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3)) /* * Manual byteshift. Best for old compilers which don't inline memcpy. * We actually directly use XXH_readLE64 and XXH_readBE64. */ #elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2)) /* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */ static xxh_u64 XXH_read64(const void* memPtr) { return *(const xxh_u64*) memPtr; } #elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1)) /* * __pack instructions are safer, but compiler specific, hence potentially * problematic for some compilers. * * Currently only defined for GCC and ICC. */ #ifdef XXH_OLD_NAMES typedef union { xxh_u32 u32; xxh_u64 u64; } __attribute__((packed)) unalign64; #endif static xxh_u64 XXH_read64(const void* ptr) { typedef union { xxh_u32 u32; xxh_u64 u64; } __attribute__((packed)) xxh_unalign64; return ((const xxh_unalign64*)ptr)->u64; } #else /* * Portable and safe solution. Generally efficient. * see: https://stackoverflow.com/a/32095106/646947 */ static xxh_u64 XXH_read64(const void* memPtr) { xxh_u64 val; memcpy(&val, memPtr, sizeof(val)); return val; } #endif /* XXH_FORCE_DIRECT_MEMORY_ACCESS */ #if defined(_MSC_VER) /* Visual Studio */ # define XXH_swap64 _byteswap_uint64 #elif XXH_GCC_VERSION >= 403 # define XXH_swap64 __builtin_bswap64 #else static xxh_u64 XXH_swap64(xxh_u64 x) { return ((x << 56) & 0xff00000000000000ULL) | ((x << 40) & 0x00ff000000000000ULL) | ((x << 24) & 0x0000ff0000000000ULL) | ((x << 8) & 0x000000ff00000000ULL) | ((x >> 8) & 0x00000000ff000000ULL) | ((x >> 24) & 0x0000000000ff0000ULL) | ((x >> 40) & 0x000000000000ff00ULL) | ((x >> 56) & 0x00000000000000ffULL); } #endif /* XXH_FORCE_MEMORY_ACCESS==3 is an endian-independent byteshift load. */ #if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3)) XXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* memPtr) { const xxh_u8* bytePtr = (const xxh_u8 *)memPtr; return bytePtr[0] | ((xxh_u64)bytePtr[1] << 8) | ((xxh_u64)bytePtr[2] << 16) | ((xxh_u64)bytePtr[3] << 24) | ((xxh_u64)bytePtr[4] << 32) | ((xxh_u64)bytePtr[5] << 40) | ((xxh_u64)bytePtr[6] << 48) | ((xxh_u64)bytePtr[7] << 56); } XXH_FORCE_INLINE xxh_u64 XXH_readBE64(const void* memPtr) { const xxh_u8* bytePtr = (const xxh_u8 *)memPtr; return bytePtr[7] | ((xxh_u64)bytePtr[6] << 8) | ((xxh_u64)bytePtr[5] << 16) | ((xxh_u64)bytePtr[4] << 24) | ((xxh_u64)bytePtr[3] << 32) | ((xxh_u64)bytePtr[2] << 40) | ((xxh_u64)bytePtr[1] << 48) | ((xxh_u64)bytePtr[0] << 56); } #else XXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* ptr) { return XXH_CPU_LITTLE_ENDIAN ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr)); } static xxh_u64 XXH_readBE64(const void* ptr) { return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr); } #endif XXH_FORCE_INLINE xxh_u64 XXH_readLE64_align(const void* ptr, XXH_alignment align) { if (align==XXH_unaligned) return XXH_readLE64(ptr); else return XXH_CPU_LITTLE_ENDIAN ? *(const xxh_u64*)ptr : XXH_swap64(*(const xxh_u64*)ptr); } /******* xxh64 *******/ /*! * @} * @defgroup xxh64_impl XXH64 implementation * @ingroup impl * @{ */ /* #define rather that static const, to be used as initializers */ #define XXH_PRIME64_1 0x9E3779B185EBCA87ULL /*!< 0b1001111000110111011110011011000110000101111010111100101010000111 */ #define XXH_PRIME64_2 0xC2B2AE3D27D4EB4FULL /*!< 0b1100001010110010101011100011110100100111110101001110101101001111 */ #define XXH_PRIME64_3 0x165667B19E3779F9ULL /*!< 0b0001011001010110011001111011000110011110001101110111100111111001 */ #define XXH_PRIME64_4 0x85EBCA77C2B2AE63ULL /*!< 0b1000010111101011110010100111011111000010101100101010111001100011 */ #define XXH_PRIME64_5 0x27D4EB2F165667C5ULL /*!< 0b0010011111010100111010110010111100010110010101100110011111000101 */ #ifdef XXH_OLD_NAMES # define PRIME64_1 XXH_PRIME64_1 # define PRIME64_2 XXH_PRIME64_2 # define PRIME64_3 XXH_PRIME64_3 # define PRIME64_4 XXH_PRIME64_4 # define PRIME64_5 XXH_PRIME64_5 #endif static xxh_u64 XXH64_round(xxh_u64 acc, xxh_u64 input) { acc += input * XXH_PRIME64_2; acc = XXH_rotl64(acc, 31); acc *= XXH_PRIME64_1; return acc; } static xxh_u64 XXH64_mergeRound(xxh_u64 acc, xxh_u64 val) { val = XXH64_round(0, val); acc ^= val; acc = acc * XXH_PRIME64_1 + XXH_PRIME64_4; return acc; } static xxh_u64 XXH64_avalanche(xxh_u64 h64) { h64 ^= h64 >> 33; h64 *= XXH_PRIME64_2; h64 ^= h64 >> 29; h64 *= XXH_PRIME64_3; h64 ^= h64 >> 32; return h64; } #define XXH_get64bits(p) XXH_readLE64_align(p, align) static xxh_u64 XXH64_finalize(xxh_u64 h64, const xxh_u8* ptr, size_t len, XXH_alignment align) { len &= 31; while (len >= 8) { xxh_u64 const k1 = XXH64_round(0, XXH_get64bits(ptr)); ptr += 8; h64 ^= k1; h64 = XXH_rotl64(h64,27) * XXH_PRIME64_1 + XXH_PRIME64_4; len -= 8; } if (len >= 4) { h64 ^= (xxh_u64)(XXH_get32bits(ptr)) * XXH_PRIME64_1; ptr += 4; h64 = XXH_rotl64(h64, 23) * XXH_PRIME64_2 + XXH_PRIME64_3; len -= 4; } while (len > 0) { h64 ^= (*ptr++) * XXH_PRIME64_5; h64 = XXH_rotl64(h64, 11) * XXH_PRIME64_1; --len; } return XXH64_avalanche(h64); } #ifdef XXH_OLD_NAMES # define PROCESS1_64 XXH_PROCESS1_64 # define PROCESS4_64 XXH_PROCESS4_64 # define PROCESS8_64 XXH_PROCESS8_64 #else # undef XXH_PROCESS1_64 # undef XXH_PROCESS4_64 # undef XXH_PROCESS8_64 #endif XXH_FORCE_INLINE xxh_u64 XXH64_endian_align(const xxh_u8* input, size_t len, xxh_u64 seed, XXH_alignment align) { const xxh_u8* bEnd = input + len; xxh_u64 h64; #if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1) if (input==NULL) { len=0; bEnd=input=(const xxh_u8*)(size_t)32; } #endif if (len>=32) { const xxh_u8* const limit = bEnd - 32; xxh_u64 v1 = seed + XXH_PRIME64_1 + XXH_PRIME64_2; xxh_u64 v2 = seed + XXH_PRIME64_2; xxh_u64 v3 = seed + 0; xxh_u64 v4 = seed - XXH_PRIME64_1; do { v1 = XXH64_round(v1, XXH_get64bits(input)); input+=8; v2 = XXH64_round(v2, XXH_get64bits(input)); input+=8; v3 = XXH64_round(v3, XXH_get64bits(input)); input+=8; v4 = XXH64_round(v4, XXH_get64bits(input)); input+=8; } while (input<=limit); h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18); h64 = XXH64_mergeRound(h64, v1); h64 = XXH64_mergeRound(h64, v2); h64 = XXH64_mergeRound(h64, v3); h64 = XXH64_mergeRound(h64, v4); } else { h64 = seed + XXH_PRIME64_5; } h64 += (xxh_u64) len; return XXH64_finalize(h64, input, len, align); } /*! @ingroup xxh64_family */ XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t len, XXH64_hash_t seed) { #if 0 /* Simple version, good for code maintenance, but unfortunately slow for small inputs */ XXH64_state_t state; XXH64_reset(&state, seed); XXH64_update(&state, (const xxh_u8*)input, len); return XXH64_digest(&state); #else if (XXH_FORCE_ALIGN_CHECK) { if ((((size_t)input) & 7)==0) { /* Input is aligned, let's leverage the speed advantage */ return XXH64_endian_align((const xxh_u8*)input, len, seed, XXH_aligned); } } return XXH64_endian_align((const xxh_u8*)input, len, seed, XXH_unaligned); #endif } /******* Hash Streaming *******/ /*! @ingroup xxh64_family*/ XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void) { return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t)); } /*! @ingroup xxh64_family */ XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr) { XXH_free(statePtr); return XXH_OK; } /*! @ingroup xxh64_family */ XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dstState, const XXH64_state_t* srcState) { memcpy(dstState, srcState, sizeof(*dstState)); } /*! @ingroup xxh64_family */ XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, XXH64_hash_t seed) { XXH64_state_t state; /* use a local state to memcpy() in order to avoid strict-aliasing warnings */ memset(&state, 0, sizeof(state)); state.v1 = seed + XXH_PRIME64_1 + XXH_PRIME64_2; state.v2 = seed + XXH_PRIME64_2; state.v3 = seed + 0; state.v4 = seed - XXH_PRIME64_1; /* do not write into reserved64, might be removed in a future version */ memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved64)); return XXH_OK; } /*! @ingroup xxh64_family */ XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state, const void* input, size_t len) { if (input==NULL) #if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1) return XXH_OK; #else return XXH_ERROR; #endif { const xxh_u8* p = (const xxh_u8*)input; const xxh_u8* const bEnd = p + len; state->total_len += len; if (state->memsize + len < 32) { /* fill in tmp buffer */ XXH_memcpy(((xxh_u8*)state->mem64) + state->memsize, input, len); state->memsize += (xxh_u32)len; return XXH_OK; } if (state->memsize) { /* tmp buffer is full */ XXH_memcpy(((xxh_u8*)state->mem64) + state->memsize, input, 32-state->memsize); state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0)); state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1)); state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2)); state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3)); p += 32 - state->memsize; state->memsize = 0; } if (p+32 <= bEnd) { const xxh_u8* const limit = bEnd - 32; xxh_u64 v1 = state->v1; xxh_u64 v2 = state->v2; xxh_u64 v3 = state->v3; xxh_u64 v4 = state->v4; do { v1 = XXH64_round(v1, XXH_readLE64(p)); p+=8; v2 = XXH64_round(v2, XXH_readLE64(p)); p+=8; v3 = XXH64_round(v3, XXH_readLE64(p)); p+=8; v4 = XXH64_round(v4, XXH_readLE64(p)); p+=8; } while (p<=limit); state->v1 = v1; state->v2 = v2; state->v3 = v3; state->v4 = v4; } if (p < bEnd) { XXH_memcpy(state->mem64, p, (size_t)(bEnd-p)); state->memsize = (unsigned)(bEnd-p); } } return XXH_OK; } /*! @ingroup xxh64_family */ XXH_PUBLIC_API XXH64_hash_t XXH64_digest(const XXH64_state_t* state) { xxh_u64 h64; if (state->total_len >= 32) { xxh_u64 const v1 = state->v1; xxh_u64 const v2 = state->v2; xxh_u64 const v3 = state->v3; xxh_u64 const v4 = state->v4; h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18); h64 = XXH64_mergeRound(h64, v1); h64 = XXH64_mergeRound(h64, v2); h64 = XXH64_mergeRound(h64, v3); h64 = XXH64_mergeRound(h64, v4); } else { h64 = state->v3 /*seed*/ + XXH_PRIME64_5; } h64 += (xxh_u64) state->total_len; return XXH64_finalize(h64, (const xxh_u8*)state->mem64, (size_t)state->total_len, XXH_aligned); } /******* Canonical representation *******/ /*! @ingroup xxh64_family */ XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash) { XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t)); if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash); memcpy(dst, &hash, sizeof(*dst)); } /*! @ingroup xxh64_family */ XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src) { return XXH_readBE64(src); } #ifndef XXH_NO_XXH3 /* ********************************************************************* * XXH3 * New generation hash designed for speed on small keys and vectorization ************************************************************************ */ /*! * @} * @defgroup xxh3_impl XXH3 implementation * @ingroup impl * @{ */ /* === Compiler specifics === */ #if ((defined(sun) || defined(__sun)) && __cplusplus) /* Solaris includes __STDC_VERSION__ with C++. Tested with GCC 5.5 */ # define XXH_RESTRICT /* disable */ #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* >= C99 */ # define XXH_RESTRICT restrict #else /* Note: it might be useful to define __restrict or __restrict__ for some C++ compilers */ # define XXH_RESTRICT /* disable */ #endif #if (defined(__GNUC__) && (__GNUC__ >= 3)) \ || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) \ || defined(__clang__) # define XXH_likely(x) __builtin_expect(x, 1) # define XXH_unlikely(x) __builtin_expect(x, 0) #else # define XXH_likely(x) (x) # define XXH_unlikely(x) (x) #endif #if defined(__GNUC__) # if defined(__AVX2__) # include # elif defined(__SSE2__) # include # elif defined(__ARM_NEON__) || defined(__ARM_NEON) # define inline __inline__ /* circumvent a clang bug */ # include # undef inline # endif #elif defined(_MSC_VER) # include #endif /* * One goal of XXH3 is to make it fast on both 32-bit and 64-bit, while * remaining a true 64-bit/128-bit hash function. * * This is done by prioritizing a subset of 64-bit operations that can be * emulated without too many steps on the average 32-bit machine. * * For example, these two lines seem similar, and run equally fast on 64-bit: * * xxh_u64 x; * x ^= (x >> 47); // good * x ^= (x >> 13); // bad * * However, to a 32-bit machine, there is a major difference. * * x ^= (x >> 47) looks like this: * * x.lo ^= (x.hi >> (47 - 32)); * * while x ^= (x >> 13) looks like this: * * // note: funnel shifts are not usually cheap. * x.lo ^= (x.lo >> 13) | (x.hi << (32 - 13)); * x.hi ^= (x.hi >> 13); * * The first one is significantly faster than the second, simply because the * shift is larger than 32. This means: * - All the bits we need are in the upper 32 bits, so we can ignore the lower * 32 bits in the shift. * - The shift result will always fit in the lower 32 bits, and therefore, * we can ignore the upper 32 bits in the xor. * * Thanks to this optimization, XXH3 only requires these features to be efficient: * * - Usable unaligned access * - A 32-bit or 64-bit ALU * - If 32-bit, a decent ADC instruction * - A 32 or 64-bit multiply with a 64-bit result * - For the 128-bit variant, a decent byteswap helps short inputs. * * The first two are already required by XXH32, and almost all 32-bit and 64-bit * platforms which can run XXH32 can run XXH3 efficiently. * * Thumb-1, the classic 16-bit only subset of ARM's instruction set, is one * notable exception. * * First of all, Thumb-1 lacks support for the UMULL instruction which * performs the important long multiply. This means numerous __aeabi_lmul * calls. * * Second of all, the 8 functional registers are just not enough. * Setup for __aeabi_lmul, byteshift loads, pointers, and all arithmetic need * Lo registers, and this shuffling results in thousands more MOVs than A32. * * A32 and T32 don't have this limitation. They can access all 14 registers, * do a 32->64 multiply with UMULL, and the flexible operand allowing free * shifts is helpful, too. * * Therefore, we do a quick sanity check. * * If compiling Thumb-1 for a target which supports ARM instructions, we will * emit a warning, as it is not a "sane" platform to compile for. * * Usually, if this happens, it is because of an accident and you probably need * to specify -march, as you likely meant to compile for a newer architecture. * * Credit: large sections of the vectorial and asm source code paths * have been contributed by @easyaspi314 */ #if defined(__thumb__) && !defined(__thumb2__) && defined(__ARM_ARCH_ISA_ARM) # warning "XXH3 is highly inefficient without ARM or Thumb-2." #endif /* ========================================== * Vectorization detection * ========================================== */ #ifdef XXH_DOXYGEN /*! * @ingroup tuning * @brief Overrides the vectorization implementation chosen for XXH3. * * Can be defined to 0 to disable SIMD or any of the values mentioned in * @ref XXH_VECTOR_TYPE. * * If this is not defined, it uses predefined macros to determine the best * implementation. */ # define XXH_VECTOR XXH_SCALAR /*! * @ingroup tuning * @brief Possible values for @ref XXH_VECTOR. * * Note that these are actually implemented as macros. * * If this is not defined, it is detected automatically. * @ref XXH_X86DISPATCH overrides this. */ enum XXH_VECTOR_TYPE /* fake enum */ { XXH_SCALAR = 0, /*!< Portable scalar version */ XXH_SSE2 = 1, /*!< * SSE2 for Pentium 4, Opteron, all x86_64. * * @note SSE2 is also guaranteed on Windows 10, macOS, and * Android x86. */ XXH_AVX2 = 2, /*!< AVX2 for Haswell and Bulldozer */ XXH_AVX512 = 3, /*!< AVX512 for Skylake and Icelake */ XXH_NEON = 4, /*!< NEON for most ARMv7-A and all AArch64 */ XXH_VSX = 5, /*!< VSX and ZVector for POWER8/z13 (64-bit) */ }; /*! * @ingroup tuning * @brief Selects the minimum alignment for XXH3's accumulators. * * When using SIMD, this should match the alignment reqired for said vector * type, so, for example, 32 for AVX2. * * Default: Auto detected. */ # define XXH_ACC_ALIGN 8 #endif /* Actual definition */ #ifndef XXH_DOXYGEN # define XXH_SCALAR 0 # define XXH_SSE2 1 # define XXH_AVX2 2 # define XXH_AVX512 3 # define XXH_NEON 4 # define XXH_VSX 5 #endif #ifndef XXH_VECTOR /* can be defined on command line */ # if defined(__AVX512F__) # define XXH_VECTOR XXH_AVX512 # elif defined(__AVX2__) # define XXH_VECTOR XXH_AVX2 # elif defined(__SSE2__) || defined(_M_AMD64) || defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP == 2)) # define XXH_VECTOR XXH_SSE2 # elif defined(__GNUC__) /* msvc support maybe later */ \ && (defined(__ARM_NEON__) || defined(__ARM_NEON)) \ && (defined(__LITTLE_ENDIAN__) /* We only support little endian NEON */ \ || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) # define XXH_VECTOR XXH_NEON # elif (defined(__PPC64__) && defined(__POWER8_VECTOR__)) \ || (defined(__s390x__) && defined(__VEC__)) \ && defined(__GNUC__) /* TODO: IBM XL */ # define XXH_VECTOR XXH_VSX # else # define XXH_VECTOR XXH_SCALAR # endif #endif /* * Controls the alignment of the accumulator, * for compatibility with aligned vector loads, which are usually faster. */ #ifndef XXH_ACC_ALIGN # if defined(XXH_X86DISPATCH) # define XXH_ACC_ALIGN 64 /* for compatibility with avx512 */ # elif XXH_VECTOR == XXH_SCALAR /* scalar */ # define XXH_ACC_ALIGN 8 # elif XXH_VECTOR == XXH_SSE2 /* sse2 */ # define XXH_ACC_ALIGN 16 # elif XXH_VECTOR == XXH_AVX2 /* avx2 */ # define XXH_ACC_ALIGN 32 # elif XXH_VECTOR == XXH_NEON /* neon */ # define XXH_ACC_ALIGN 16 # elif XXH_VECTOR == XXH_VSX /* vsx */ # define XXH_ACC_ALIGN 16 # elif XXH_VECTOR == XXH_AVX512 /* avx512 */ # define XXH_ACC_ALIGN 64 # endif #endif #if defined(XXH_X86DISPATCH) || XXH_VECTOR == XXH_SSE2 \ || XXH_VECTOR == XXH_AVX2 || XXH_VECTOR == XXH_AVX512 # define XXH_SEC_ALIGN XXH_ACC_ALIGN #else # define XXH_SEC_ALIGN 8 #endif /* * UGLY HACK: * GCC usually generates the best code with -O3 for xxHash. * * However, when targeting AVX2, it is overzealous in its unrolling resulting * in code roughly 3/4 the speed of Clang. * * There are other issues, such as GCC splitting _mm256_loadu_si256 into * _mm_loadu_si128 + _mm256_inserti128_si256. This is an optimization which * only applies to Sandy and Ivy Bridge... which don't even support AVX2. * * That is why when compiling the AVX2 version, it is recommended to use either * -O2 -mavx2 -march=haswell * or * -O2 -mavx2 -mno-avx256-split-unaligned-load * for decent performance, or to use Clang instead. * * Fortunately, we can control the first one with a pragma that forces GCC into * -O2, but the other one we can't control without "failed to inline always * inline function due to target mismatch" warnings. */ #if XXH_VECTOR == XXH_AVX2 /* AVX2 */ \ && defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \ && defined(__OPTIMIZE__) && !defined(__OPTIMIZE_SIZE__) /* respect -O0 and -Os */ # pragma GCC push_options # pragma GCC optimize("-O2") #endif #if XXH_VECTOR == XXH_NEON /* * NEON's setup for vmlal_u32 is a little more complicated than it is on * SSE2, AVX2, and VSX. * * While PMULUDQ and VMULEUW both perform a mask, VMLAL.U32 performs an upcast. * * To do the same operation, the 128-bit 'Q' register needs to be split into * two 64-bit 'D' registers, performing this operation:: * * [ a | b ] * | '---------. .--------' | * | x | * | .---------' '--------. | * [ a & 0xFFFFFFFF | b & 0xFFFFFFFF ],[ a >> 32 | b >> 32 ] * * Due to significant changes in aarch64, the fastest method for aarch64 is * completely different than the fastest method for ARMv7-A. * * ARMv7-A treats D registers as unions overlaying Q registers, so modifying * D11 will modify the high half of Q5. This is similar to how modifying AH * will only affect bits 8-15 of AX on x86. * * VZIP takes two registers, and puts even lanes in one register and odd lanes * in the other. * * On ARMv7-A, this strangely modifies both parameters in place instead of * taking the usual 3-operand form. * * Therefore, if we want to do this, we can simply use a D-form VZIP.32 on the * lower and upper halves of the Q register to end up with the high and low * halves where we want - all in one instruction. * * vzip.32 d10, d11 @ d10 = { d10[0], d11[0] }; d11 = { d10[1], d11[1] } * * Unfortunately we need inline assembly for this: Instructions modifying two * registers at once is not possible in GCC or Clang's IR, and they have to * create a copy. * * aarch64 requires a different approach. * * In order to make it easier to write a decent compiler for aarch64, many * quirks were removed, such as conditional execution. * * NEON was also affected by this. * * aarch64 cannot access the high bits of a Q-form register, and writes to a * D-form register zero the high bits, similar to how writes to W-form scalar * registers (or DWORD registers on x86_64) work. * * The formerly free vget_high intrinsics now require a vext (with a few * exceptions) * * Additionally, VZIP was replaced by ZIP1 and ZIP2, which are the equivalent * of PUNPCKL* and PUNPCKH* in SSE, respectively, in order to only modify one * operand. * * The equivalent of the VZIP.32 on the lower and upper halves would be this * mess: * * ext v2.4s, v0.4s, v0.4s, #2 // v2 = { v0[2], v0[3], v0[0], v0[1] } * zip1 v1.2s, v0.2s, v2.2s // v1 = { v0[0], v2[0] } * zip2 v0.2s, v0.2s, v1.2s // v0 = { v0[1], v2[1] } * * Instead, we use a literal downcast, vmovn_u64 (XTN), and vshrn_n_u64 (SHRN): * * shrn v1.2s, v0.2d, #32 // v1 = (uint32x2_t)(v0 >> 32); * xtn v0.2s, v0.2d // v0 = (uint32x2_t)(v0 & 0xFFFFFFFF); * * This is available on ARMv7-A, but is less efficient than a single VZIP.32. */ /*! * Function-like macro: * void XXH_SPLIT_IN_PLACE(uint64x2_t &in, uint32x2_t &outLo, uint32x2_t &outHi) * { * outLo = (uint32x2_t)(in & 0xFFFFFFFF); * outHi = (uint32x2_t)(in >> 32); * in = UNDEFINED; * } */ # if !defined(XXH_NO_VZIP_HACK) /* define to disable */ \ && defined(__GNUC__) \ && !defined(__aarch64__) && !defined(__arm64__) # define XXH_SPLIT_IN_PLACE(in, outLo, outHi) \ do { \ /* Undocumented GCC/Clang operand modifier: %e0 = lower D half, %f0 = upper D half */ \ /* https://github.com/gcc-mirror/gcc/blob/38cf91e5/gcc/config/arm/arm.c#L22486 */ \ /* https://github.com/llvm-mirror/llvm/blob/2c4ca683/lib/Target/ARM/ARMAsmPrinter.cpp#L399 */ \ __asm__("vzip.32 %e0, %f0" : "+w" (in)); \ (outLo) = vget_low_u32 (vreinterpretq_u32_u64(in)); \ (outHi) = vget_high_u32(vreinterpretq_u32_u64(in)); \ } while (0) # else # define XXH_SPLIT_IN_PLACE(in, outLo, outHi) \ do { \ (outLo) = vmovn_u64 (in); \ (outHi) = vshrn_n_u64 ((in), 32); \ } while (0) # endif #endif /* XXH_VECTOR == XXH_NEON */ /* * VSX and Z Vector helpers. * * This is very messy, and any pull requests to clean this up are welcome. * * There are a lot of problems with supporting VSX and s390x, due to * inconsistent intrinsics, spotty coverage, and multiple endiannesses. */ #if XXH_VECTOR == XXH_VSX # if defined(__s390x__) # include # else /* gcc's altivec.h can have the unwanted consequence to unconditionally * #define bool, vector, and pixel keywords, * with bad consequences for programs already using these keywords for other purposes. * The paragraph defining these macros is skipped when __APPLE_ALTIVEC__ is defined. * __APPLE_ALTIVEC__ is _generally_ defined automatically by the compiler, * but it seems that, in some cases, it isn't. * Force the build macro to be defined, so that keywords are not altered. */ # if defined(__GNUC__) && !defined(__APPLE_ALTIVEC__) # define __APPLE_ALTIVEC__ # endif # include # endif typedef __vector unsigned long long xxh_u64x2; typedef __vector unsigned char xxh_u8x16; typedef __vector unsigned xxh_u32x4; # ifndef XXH_VSX_BE # if defined(__BIG_ENDIAN__) \ || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) # define XXH_VSX_BE 1 # elif defined(__VEC_ELEMENT_REG_ORDER__) && __VEC_ELEMENT_REG_ORDER__ == __ORDER_BIG_ENDIAN__ # warning "-maltivec=be is not recommended. Please use native endianness." # define XXH_VSX_BE 1 # else # define XXH_VSX_BE 0 # endif # endif /* !defined(XXH_VSX_BE) */ # if XXH_VSX_BE # if defined(__POWER9_VECTOR__) || (defined(__clang__) && defined(__s390x__)) # define XXH_vec_revb vec_revb # else /*! * A polyfill for POWER9's vec_revb(). */ XXH_FORCE_INLINE xxh_u64x2 XXH_vec_revb(xxh_u64x2 val) { xxh_u8x16 const vByteSwap = { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08 }; return vec_perm(val, val, vByteSwap); } # endif # endif /* XXH_VSX_BE */ /*! * Performs an unaligned vector load and byte swaps it on big endian. */ XXH_FORCE_INLINE xxh_u64x2 XXH_vec_loadu(const void *ptr) { xxh_u64x2 ret; memcpy(&ret, ptr, sizeof(xxh_u64x2)); # if XXH_VSX_BE ret = XXH_vec_revb(ret); # endif return ret; } /* * vec_mulo and vec_mule are very problematic intrinsics on PowerPC * * These intrinsics weren't added until GCC 8, despite existing for a while, * and they are endian dependent. Also, their meaning swap depending on version. * */ # if defined(__s390x__) /* s390x is always big endian, no issue on this platform */ # define XXH_vec_mulo vec_mulo # define XXH_vec_mule vec_mule # elif defined(__clang__) && XXH_HAS_BUILTIN(__builtin_altivec_vmuleuw) /* Clang has a better way to control this, we can just use the builtin which doesn't swap. */ # define XXH_vec_mulo __builtin_altivec_vmulouw # define XXH_vec_mule __builtin_altivec_vmuleuw # else /* gcc needs inline assembly */ /* Adapted from https://github.com/google/highwayhash/blob/master/highwayhash/hh_vsx.h. */ XXH_FORCE_INLINE xxh_u64x2 XXH_vec_mulo(xxh_u32x4 a, xxh_u32x4 b) { xxh_u64x2 result; __asm__("vmulouw %0, %1, %2" : "=v" (result) : "v" (a), "v" (b)); return result; } XXH_FORCE_INLINE xxh_u64x2 XXH_vec_mule(xxh_u32x4 a, xxh_u32x4 b) { xxh_u64x2 result; __asm__("vmuleuw %0, %1, %2" : "=v" (result) : "v" (a), "v" (b)); return result; } # endif /* XXH_vec_mulo, XXH_vec_mule */ #endif /* XXH_VECTOR == XXH_VSX */ /* prefetch * can be disabled, by declaring XXH_NO_PREFETCH build macro */ #if defined(XXH_NO_PREFETCH) # define XXH_PREFETCH(ptr) (void)(ptr) /* disabled */ #else # if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86)) /* _mm_prefetch() not defined outside of x86/x64 */ # include /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */ # define XXH_PREFETCH(ptr) _mm_prefetch((const char*)(ptr), _MM_HINT_T0) # elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) ) # define XXH_PREFETCH(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */) # else # define XXH_PREFETCH(ptr) (void)(ptr) /* disabled */ # endif #endif /* XXH_NO_PREFETCH */ /* ========================================== * XXH3 default settings * ========================================== */ #define XXH_SECRET_DEFAULT_SIZE 192 /* minimum XXH3_SECRET_SIZE_MIN */ #if (XXH_SECRET_DEFAULT_SIZE < XXH3_SECRET_SIZE_MIN) # error "default keyset is not large enough" #endif /*! Pseudorandom secret taken directly from FARSH. */ XXH_ALIGN(64) static const xxh_u8 XXH3_kSecret[XXH_SECRET_DEFAULT_SIZE] = { 0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c, 0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f, 0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21, 0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c, 0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3, 0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8, 0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d, 0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64, 0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb, 0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e, 0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce, 0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e, }; #ifdef XXH_OLD_NAMES # define kSecret XXH3_kSecret #endif #ifdef XXH_DOXYGEN /*! * @brief Calculates a 32-bit to 64-bit long multiply. * * Implemented as a macro. * * Wraps `__emulu` on MSVC x86 because it tends to call `__allmul` when it doesn't * need to (but it shouldn't need to anyways, it is about 7 instructions to do * a 64x64 multiply...). Since we know that this will _always_ emit `MULL`, we * use that instead of the normal method. * * If you are compiling for platforms like Thumb-1 and don't have a better option, * you may also want to write your own long multiply routine here. * * @param x, y Numbers to be multiplied * @return 64-bit product of the low 32 bits of @p x and @p y. */ XXH_FORCE_INLINE xxh_u64 XXH_mult32to64(xxh_u64 x, xxh_u64 y) { return (x & 0xFFFFFFFF) * (y & 0xFFFFFFFF); } #elif defined(_MSC_VER) && defined(_M_IX86) # include # define XXH_mult32to64(x, y) __emulu((unsigned)(x), (unsigned)(y)) #else /* * Downcast + upcast is usually better than masking on older compilers like * GCC 4.2 (especially 32-bit ones), all without affecting newer compilers. * * The other method, (x & 0xFFFFFFFF) * (y & 0xFFFFFFFF), will AND both operands * and perform a full 64x64 multiply -- entirely redundant on 32-bit. */ # define XXH_mult32to64(x, y) ((xxh_u64)(xxh_u32)(x) * (xxh_u64)(xxh_u32)(y)) #endif /*! * @brief Calculates a 64->128-bit long multiply. * * Uses `__uint128_t` and `_umul128` if available, otherwise uses a scalar * version. * * @param lhs, rhs The 64-bit integers to be multiplied * @return The 128-bit result represented in an @ref XXH128_hash_t. */ static XXH128_hash_t XXH_mult64to128(xxh_u64 lhs, xxh_u64 rhs) { /* * GCC/Clang __uint128_t method. * * On most 64-bit targets, GCC and Clang define a __uint128_t type. * This is usually the best way as it usually uses a native long 64-bit * multiply, such as MULQ on x86_64 or MUL + UMULH on aarch64. * * Usually. * * Despite being a 32-bit platform, Clang (and emscripten) define this type * despite not having the arithmetic for it. This results in a laggy * compiler builtin call which calculates a full 128-bit multiply. * In that case it is best to use the portable one. * https://github.com/Cyan4973/xxHash/issues/211#issuecomment-515575677 */ #if defined(__GNUC__) && !defined(__wasm__) \ && defined(__SIZEOF_INT128__) \ || (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 128) __uint128_t const product = (__uint128_t)lhs * (__uint128_t)rhs; XXH128_hash_t r128; r128.low64 = (xxh_u64)(product); r128.high64 = (xxh_u64)(product >> 64); return r128; /* * MSVC for x64's _umul128 method. * * xxh_u64 _umul128(xxh_u64 Multiplier, xxh_u64 Multiplicand, xxh_u64 *HighProduct); * * This compiles to single operand MUL on x64. */ #elif defined(_M_X64) || defined(_M_IA64) #ifndef _MSC_VER # pragma intrinsic(_umul128) #endif xxh_u64 product_high; xxh_u64 const product_low = _umul128(lhs, rhs, &product_high); XXH128_hash_t r128; r128.low64 = product_low; r128.high64 = product_high; return r128; #else /* * Portable scalar method. Optimized for 32-bit and 64-bit ALUs. * * This is a fast and simple grade school multiply, which is shown below * with base 10 arithmetic instead of base 0x100000000. * * 9 3 // D2 lhs = 93 * x 7 5 // D2 rhs = 75 * ---------- * 1 5 // D2 lo_lo = (93 % 10) * (75 % 10) = 15 * 4 5 | // D2 hi_lo = (93 / 10) * (75 % 10) = 45 * 2 1 | // D2 lo_hi = (93 % 10) * (75 / 10) = 21 * + 6 3 | | // D2 hi_hi = (93 / 10) * (75 / 10) = 63 * --------- * 2 7 | // D2 cross = (15 / 10) + (45 % 10) + 21 = 27 * + 6 7 | | // D2 upper = (27 / 10) + (45 / 10) + 63 = 67 * --------- * 6 9 7 5 // D4 res = (27 * 10) + (15 % 10) + (67 * 100) = 6975 * * The reasons for adding the products like this are: * 1. It avoids manual carry tracking. Just like how * (9 * 9) + 9 + 9 = 99, the same applies with this for UINT64_MAX. * This avoids a lot of complexity. * * 2. It hints for, and on Clang, compiles to, the powerful UMAAL * instruction available in ARM's Digital Signal Processing extension * in 32-bit ARMv6 and later, which is shown below: * * void UMAAL(xxh_u32 *RdLo, xxh_u32 *RdHi, xxh_u32 Rn, xxh_u32 Rm) * { * xxh_u64 product = (xxh_u64)*RdLo * (xxh_u64)*RdHi + Rn + Rm; * *RdLo = (xxh_u32)(product & 0xFFFFFFFF); * *RdHi = (xxh_u32)(product >> 32); * } * * This instruction was designed for efficient long multiplication, and * allows this to be calculated in only 4 instructions at speeds * comparable to some 64-bit ALUs. * * 3. It isn't terrible on other platforms. Usually this will be a couple * of 32-bit ADD/ADCs. */ /* First calculate all of the cross products. */ xxh_u64 const lo_lo = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs & 0xFFFFFFFF); xxh_u64 const hi_lo = XXH_mult32to64(lhs >> 32, rhs & 0xFFFFFFFF); xxh_u64 const lo_hi = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs >> 32); xxh_u64 const hi_hi = XXH_mult32to64(lhs >> 32, rhs >> 32); /* Now add the products together. These will never overflow. */ xxh_u64 const cross = (lo_lo >> 32) + (hi_lo & 0xFFFFFFFF) + lo_hi; xxh_u64 const upper = (hi_lo >> 32) + (cross >> 32) + hi_hi; xxh_u64 const lower = (cross << 32) | (lo_lo & 0xFFFFFFFF); XXH128_hash_t r128; r128.low64 = lower; r128.high64 = upper; return r128; #endif } /*! * @brief Calculates a 64-bit to 128-bit multiply, then XOR folds it. * * The reason for the separate function is to prevent passing too many structs * around by value. This will hopefully inline the multiply, but we don't force it. * * @param lhs, rhs The 64-bit integers to multiply * @return The low 64 bits of the product XOR'd by the high 64 bits. * @see XXH_mult64to128() */ static xxh_u64 XXH3_mul128_fold64(xxh_u64 lhs, xxh_u64 rhs) { XXH128_hash_t product = XXH_mult64to128(lhs, rhs); return product.low64 ^ product.high64; } /*! Seems to produce slightly better code on GCC for some reason. */ XXH_FORCE_INLINE xxh_u64 XXH_xorshift64(xxh_u64 v64, int shift) { XXH_ASSERT(0 <= shift && shift < 64); return v64 ^ (v64 >> shift); } /* * This is a fast avalanche stage, * suitable when input bits are already partially mixed */ static XXH64_hash_t XXH3_avalanche(xxh_u64 h64) { h64 = XXH_xorshift64(h64, 37); h64 *= 0x165667919E3779F9ULL; h64 = XXH_xorshift64(h64, 32); return h64; } /* * This is a stronger avalanche, * inspired by Pelle Evensen's rrmxmx * preferable when input has not been previously mixed */ static XXH64_hash_t XXH3_rrmxmx(xxh_u64 h64, xxh_u64 len) { /* this mix is inspired by Pelle Evensen's rrmxmx */ h64 ^= XXH_rotl64(h64, 49) ^ XXH_rotl64(h64, 24); h64 *= 0x9FB21C651E98DF25ULL; h64 ^= (h64 >> 35) + len ; h64 *= 0x9FB21C651E98DF25ULL; return XXH_xorshift64(h64, 28); } /* ========================================== * Short keys * ========================================== * One of the shortcomings of XXH32 and XXH64 was that their performance was * sub-optimal on short lengths. It used an iterative algorithm which strongly * favored lengths that were a multiple of 4 or 8. * * Instead of iterating over individual inputs, we use a set of single shot * functions which piece together a range of lengths and operate in constant time. * * Additionally, the number of multiplies has been significantly reduced. This * reduces latency, especially when emulating 64-bit multiplies on 32-bit. * * Depending on the platform, this may or may not be faster than XXH32, but it * is almost guaranteed to be faster than XXH64. */ /* * At very short lengths, there isn't enough input to fully hide secrets, or use * the entire secret. * * There is also only a limited amount of mixing we can do before significantly * impacting performance. * * Therefore, we use different sections of the secret and always mix two secret * samples with an XOR. This should have no effect on performance on the * seedless or withSeed variants because everything _should_ be constant folded * by modern compilers. * * The XOR mixing hides individual parts of the secret and increases entropy. * * This adds an extra layer of strength for custom secrets. */ XXH_FORCE_INLINE XXH64_hash_t XXH3_len_1to3_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed) { XXH_ASSERT(input != NULL); XXH_ASSERT(1 <= len && len <= 3); XXH_ASSERT(secret != NULL); /* * len = 1: combined = { input[0], 0x01, input[0], input[0] } * len = 2: combined = { input[1], 0x02, input[0], input[1] } * len = 3: combined = { input[2], 0x03, input[0], input[1] } */ { xxh_u8 const c1 = input[0]; xxh_u8 const c2 = input[len >> 1]; xxh_u8 const c3 = input[len - 1]; xxh_u32 const combined = ((xxh_u32)c1 << 16) | ((xxh_u32)c2 << 24) | ((xxh_u32)c3 << 0) | ((xxh_u32)len << 8); xxh_u64 const bitflip = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed; xxh_u64 const keyed = (xxh_u64)combined ^ bitflip; return XXH64_avalanche(keyed); } } XXH_FORCE_INLINE XXH64_hash_t XXH3_len_4to8_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed) { XXH_ASSERT(input != NULL); XXH_ASSERT(secret != NULL); XXH_ASSERT(4 <= len && len <= 8); seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32; { xxh_u32 const input1 = XXH_readLE32(input); xxh_u32 const input2 = XXH_readLE32(input + len - 4); xxh_u64 const bitflip = (XXH_readLE64(secret+8) ^ XXH_readLE64(secret+16)) - seed; xxh_u64 const input64 = input2 + (((xxh_u64)input1) << 32); xxh_u64 const keyed = input64 ^ bitflip; return XXH3_rrmxmx(keyed, len); } } XXH_FORCE_INLINE XXH64_hash_t XXH3_len_9to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed) { XXH_ASSERT(input != NULL); XXH_ASSERT(secret != NULL); XXH_ASSERT(8 <= len && len <= 16); { xxh_u64 const bitflip1 = (XXH_readLE64(secret+24) ^ XXH_readLE64(secret+32)) + seed; xxh_u64 const bitflip2 = (XXH_readLE64(secret+40) ^ XXH_readLE64(secret+48)) - seed; xxh_u64 const input_lo = XXH_readLE64(input) ^ bitflip1; xxh_u64 const input_hi = XXH_readLE64(input + len - 8) ^ bitflip2; xxh_u64 const acc = len + XXH_swap64(input_lo) + input_hi + XXH3_mul128_fold64(input_lo, input_hi); return XXH3_avalanche(acc); } } XXH_FORCE_INLINE XXH64_hash_t XXH3_len_0to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed) { XXH_ASSERT(len <= 16); { if (XXH_likely(len > 8)) return XXH3_len_9to16_64b(input, len, secret, seed); if (XXH_likely(len >= 4)) return XXH3_len_4to8_64b(input, len, secret, seed); if (len) return XXH3_len_1to3_64b(input, len, secret, seed); return XXH64_avalanche(seed ^ (XXH_readLE64(secret+56) ^ XXH_readLE64(secret+64))); } } /* * DISCLAIMER: There are known *seed-dependent* multicollisions here due to * multiplication by zero, affecting hashes of lengths 17 to 240. * * However, they are very unlikely. * * Keep this in mind when using the unseeded XXH3_64bits() variant: As with all * unseeded non-cryptographic hashes, it does not attempt to defend itself * against specially crafted inputs, only random inputs. * * Compared to classic UMAC where a 1 in 2^31 chance of 4 consecutive bytes * cancelling out the secret is taken an arbitrary number of times (addressed * in XXH3_accumulate_512), this collision is very unlikely with random inputs * and/or proper seeding: * * This only has a 1 in 2^63 chance of 8 consecutive bytes cancelling out, in a * function that is only called up to 16 times per hash with up to 240 bytes of * input. * * This is not too bad for a non-cryptographic hash function, especially with * only 64 bit outputs. * * The 128-bit variant (which trades some speed for strength) is NOT affected * by this, although it is always a good idea to use a proper seed if you care * about strength. */ XXH_FORCE_INLINE xxh_u64 XXH3_mix16B(const xxh_u8* XXH_RESTRICT input, const xxh_u8* XXH_RESTRICT secret, xxh_u64 seed64) { #if defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \ && defined(__i386__) && defined(__SSE2__) /* x86 + SSE2 */ \ && !defined(XXH_ENABLE_AUTOVECTORIZE) /* Define to disable like XXH32 hack */ /* * UGLY HACK: * GCC for x86 tends to autovectorize the 128-bit multiply, resulting in * slower code. * * By forcing seed64 into a register, we disrupt the cost model and * cause it to scalarize. See `XXH32_round()` * * FIXME: Clang's output is still _much_ faster -- On an AMD Ryzen 3600, * XXH3_64bits @ len=240 runs at 4.6 GB/s with Clang 9, but 3.3 GB/s on * GCC 9.2, despite both emitting scalar code. * * GCC generates much better scalar code than Clang for the rest of XXH3, * which is why finding a more optimal codepath is an interest. */ XXH_COMPILER_GUARD(seed64); #endif { xxh_u64 const input_lo = XXH_readLE64(input); xxh_u64 const input_hi = XXH_readLE64(input+8); return XXH3_mul128_fold64( input_lo ^ (XXH_readLE64(secret) + seed64), input_hi ^ (XXH_readLE64(secret+8) - seed64) ); } } /* For mid range keys, XXH3 uses a Mum-hash variant. */ XXH_FORCE_INLINE XXH64_hash_t XXH3_len_17to128_64b(const xxh_u8* XXH_RESTRICT input, size_t len, const xxh_u8* XXH_RESTRICT secret, size_t secretSize, XXH64_hash_t seed) { XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize; XXH_ASSERT(16 < len && len <= 128); { xxh_u64 acc = len * XXH_PRIME64_1; if (len > 32) { if (len > 64) { if (len > 96) { acc += XXH3_mix16B(input+48, secret+96, seed); acc += XXH3_mix16B(input+len-64, secret+112, seed); } acc += XXH3_mix16B(input+32, secret+64, seed); acc += XXH3_mix16B(input+len-48, secret+80, seed); } acc += XXH3_mix16B(input+16, secret+32, seed); acc += XXH3_mix16B(input+len-32, secret+48, seed); } acc += XXH3_mix16B(input+0, secret+0, seed); acc += XXH3_mix16B(input+len-16, secret+16, seed); return XXH3_avalanche(acc); } } #define XXH3_MIDSIZE_MAX 240 XXH_NO_INLINE XXH64_hash_t XXH3_len_129to240_64b(const xxh_u8* XXH_RESTRICT input, size_t len, const xxh_u8* XXH_RESTRICT secret, size_t secretSize, XXH64_hash_t seed) { XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize; XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX); #define XXH3_MIDSIZE_STARTOFFSET 3 #define XXH3_MIDSIZE_LASTOFFSET 17 { xxh_u64 acc = len * XXH_PRIME64_1; int const nbRounds = (int)len / 16; int i; for (i=0; i<8; i++) { acc += XXH3_mix16B(input+(16*i), secret+(16*i), seed); } acc = XXH3_avalanche(acc); XXH_ASSERT(nbRounds >= 8); #if defined(__clang__) /* Clang */ \ && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */ \ && !defined(XXH_ENABLE_AUTOVECTORIZE) /* Define to disable */ /* * UGLY HACK: * Clang for ARMv7-A tries to vectorize this loop, similar to GCC x86. * In everywhere else, it uses scalar code. * * For 64->128-bit multiplies, even if the NEON was 100% optimal, it * would still be slower than UMAAL (see XXH_mult64to128). * * Unfortunately, Clang doesn't handle the long multiplies properly and * converts them to the nonexistent "vmulq_u64" intrinsic, which is then * scalarized into an ugly mess of VMOV.32 instructions. * * This mess is difficult to avoid without turning autovectorization * off completely, but they are usually relatively minor and/or not * worth it to fix. * * This loop is the easiest to fix, as unlike XXH32, this pragma * _actually works_ because it is a loop vectorization instead of an * SLP vectorization. */ #pragma clang loop vectorize(disable) #endif for (i=8 ; i < nbRounds; i++) { acc += XXH3_mix16B(input+(16*i), secret+(16*(i-8)) + XXH3_MIDSIZE_STARTOFFSET, seed); } /* last bytes */ acc += XXH3_mix16B(input + len - 16, secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET, seed); return XXH3_avalanche(acc); } } /* ======= Long Keys ======= */ #define XXH_STRIPE_LEN 64 #define XXH_SECRET_CONSUME_RATE 8 /* nb of secret bytes consumed at each accumulation */ #define XXH_ACC_NB (XXH_STRIPE_LEN / sizeof(xxh_u64)) #ifdef XXH_OLD_NAMES # define STRIPE_LEN XXH_STRIPE_LEN # define ACC_NB XXH_ACC_NB #endif XXH_FORCE_INLINE void XXH_writeLE64(void* dst, xxh_u64 v64) { if (!XXH_CPU_LITTLE_ENDIAN) v64 = XXH_swap64(v64); memcpy(dst, &v64, sizeof(v64)); } /* Several intrinsic functions below are supposed to accept __int64 as argument, * as documented in https://software.intel.com/sites/landingpage/IntrinsicsGuide/ . * However, several environments do not define __int64 type, * requiring a workaround. */ #if !defined (__VMS) \ && (defined (__cplusplus) \ || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) typedef int64_t xxh_i64; #else /* the following type must have a width of 64-bit */ typedef long long xxh_i64; #endif /* * XXH3_accumulate_512 is the tightest loop for long inputs, and it is the most optimized. * * It is a hardened version of UMAC, based off of FARSH's implementation. * * This was chosen because it adapts quite well to 32-bit, 64-bit, and SIMD * implementations, and it is ridiculously fast. * * We harden it by mixing the original input to the accumulators as well as the product. * * This means that in the (relatively likely) case of a multiply by zero, the * original input is preserved. * * On 128-bit inputs, we swap 64-bit pairs when we add the input to improve * cross-pollination, as otherwise the upper and lower halves would be * essentially independent. * * This doesn't matter on 64-bit hashes since they all get merged together in * the end, so we skip the extra step. * * Both XXH3_64bits and XXH3_128bits use this subroutine. */ #if (XXH_VECTOR == XXH_AVX512) \ || (defined(XXH_DISPATCH_AVX512) && XXH_DISPATCH_AVX512 != 0) #ifndef XXH_TARGET_AVX512 # define XXH_TARGET_AVX512 /* disable attribute target */ #endif XXH_FORCE_INLINE XXH_TARGET_AVX512 void XXH3_accumulate_512_avx512(void* XXH_RESTRICT acc, const void* XXH_RESTRICT input, const void* XXH_RESTRICT secret) { XXH_ALIGN(64) __m512i* const xacc = (__m512i *) acc; XXH_ASSERT((((size_t)acc) & 63) == 0); XXH_STATIC_ASSERT(XXH_STRIPE_LEN == sizeof(__m512i)); { /* data_vec = input[0]; */ __m512i const data_vec = _mm512_loadu_si512 (input); /* key_vec = secret[0]; */ __m512i const key_vec = _mm512_loadu_si512 (secret); /* data_key = data_vec ^ key_vec; */ __m512i const data_key = _mm512_xor_si512 (data_vec, key_vec); /* data_key_lo = data_key >> 32; */ __m512i const data_key_lo = _mm512_shuffle_epi32 (data_key, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 3, 0, 1)); /* product = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */ __m512i const product = _mm512_mul_epu32 (data_key, data_key_lo); /* xacc[0] += swap(data_vec); */ __m512i const data_swap = _mm512_shuffle_epi32(data_vec, (_MM_PERM_ENUM)_MM_SHUFFLE(1, 0, 3, 2)); __m512i const sum = _mm512_add_epi64(*xacc, data_swap); /* xacc[0] += product; */ *xacc = _mm512_add_epi64(product, sum); } } /* * XXH3_scrambleAcc: Scrambles the accumulators to improve mixing. * * Multiplication isn't perfect, as explained by Google in HighwayHash: * * // Multiplication mixes/scrambles bytes 0-7 of the 64-bit result to * // varying degrees. In descending order of goodness, bytes * // 3 4 2 5 1 6 0 7 have quality 228 224 164 160 100 96 36 32. * // As expected, the upper and lower bytes are much worse. * * Source: https://github.com/google/highwayhash/blob/0aaf66b/highwayhash/hh_avx2.h#L291 * * Since our algorithm uses a pseudorandom secret to add some variance into the * mix, we don't need to (or want to) mix as often or as much as HighwayHash does. * * This isn't as tight as XXH3_accumulate, but still written in SIMD to avoid * extraction. * * Both XXH3_64bits and XXH3_128bits use this subroutine. */ XXH_FORCE_INLINE XXH_TARGET_AVX512 void XXH3_scrambleAcc_avx512(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret) { XXH_ASSERT((((size_t)acc) & 63) == 0); XXH_STATIC_ASSERT(XXH_STRIPE_LEN == sizeof(__m512i)); { XXH_ALIGN(64) __m512i* const xacc = (__m512i*) acc; const __m512i prime32 = _mm512_set1_epi32((int)XXH_PRIME32_1); /* xacc[0] ^= (xacc[0] >> 47) */ __m512i const acc_vec = *xacc; __m512i const shifted = _mm512_srli_epi64 (acc_vec, 47); __m512i const data_vec = _mm512_xor_si512 (acc_vec, shifted); /* xacc[0] ^= secret; */ __m512i const key_vec = _mm512_loadu_si512 (secret); __m512i const data_key = _mm512_xor_si512 (data_vec, key_vec); /* xacc[0] *= XXH_PRIME32_1; */ __m512i const data_key_hi = _mm512_shuffle_epi32 (data_key, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 3, 0, 1)); __m512i const prod_lo = _mm512_mul_epu32 (data_key, prime32); __m512i const prod_hi = _mm512_mul_epu32 (data_key_hi, prime32); *xacc = _mm512_add_epi64(prod_lo, _mm512_slli_epi64(prod_hi, 32)); } } XXH_FORCE_INLINE XXH_TARGET_AVX512 void XXH3_initCustomSecret_avx512(void* XXH_RESTRICT customSecret, xxh_u64 seed64) { XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 63) == 0); XXH_STATIC_ASSERT(XXH_SEC_ALIGN == 64); XXH_ASSERT(((size_t)customSecret & 63) == 0); (void)(&XXH_writeLE64); { int const nbRounds = XXH_SECRET_DEFAULT_SIZE / sizeof(__m512i); __m512i const seed = _mm512_mask_set1_epi64(_mm512_set1_epi64((xxh_i64)seed64), 0xAA, -(xxh_i64)seed64); XXH_ALIGN(64) const __m512i* const src = (const __m512i*) XXH3_kSecret; XXH_ALIGN(64) __m512i* const dest = ( __m512i*) customSecret; int i; for (i=0; i < nbRounds; ++i) { /* GCC has a bug, _mm512_stream_load_si512 accepts 'void*', not 'void const*', * this will warn "discards ‘const’ qualifier". */ union { XXH_ALIGN(64) const __m512i* cp; XXH_ALIGN(64) void* p; } remote_const_void; remote_const_void.cp = src + i; dest[i] = _mm512_add_epi64(_mm512_stream_load_si512(remote_const_void.p), seed); } } } #endif #if (XXH_VECTOR == XXH_AVX2) \ || (defined(XXH_DISPATCH_AVX2) && XXH_DISPATCH_AVX2 != 0) #ifndef XXH_TARGET_AVX2 # define XXH_TARGET_AVX2 /* disable attribute target */ #endif XXH_FORCE_INLINE XXH_TARGET_AVX2 void XXH3_accumulate_512_avx2( void* XXH_RESTRICT acc, const void* XXH_RESTRICT input, const void* XXH_RESTRICT secret) { XXH_ASSERT((((size_t)acc) & 31) == 0); { XXH_ALIGN(32) __m256i* const xacc = (__m256i *) acc; /* Unaligned. This is mainly for pointer arithmetic, and because * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */ const __m256i* const xinput = (const __m256i *) input; /* Unaligned. This is mainly for pointer arithmetic, and because * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */ const __m256i* const xsecret = (const __m256i *) secret; size_t i; for (i=0; i < XXH_STRIPE_LEN/sizeof(__m256i); i++) { /* data_vec = xinput[i]; */ __m256i const data_vec = _mm256_loadu_si256 (xinput+i); /* key_vec = xsecret[i]; */ __m256i const key_vec = _mm256_loadu_si256 (xsecret+i); /* data_key = data_vec ^ key_vec; */ __m256i const data_key = _mm256_xor_si256 (data_vec, key_vec); /* data_key_lo = data_key >> 32; */ __m256i const data_key_lo = _mm256_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1)); /* product = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */ __m256i const product = _mm256_mul_epu32 (data_key, data_key_lo); /* xacc[i] += swap(data_vec); */ __m256i const data_swap = _mm256_shuffle_epi32(data_vec, _MM_SHUFFLE(1, 0, 3, 2)); __m256i const sum = _mm256_add_epi64(xacc[i], data_swap); /* xacc[i] += product; */ xacc[i] = _mm256_add_epi64(product, sum); } } } XXH_FORCE_INLINE XXH_TARGET_AVX2 void XXH3_scrambleAcc_avx2(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret) { XXH_ASSERT((((size_t)acc) & 31) == 0); { XXH_ALIGN(32) __m256i* const xacc = (__m256i*) acc; /* Unaligned. This is mainly for pointer arithmetic, and because * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */ const __m256i* const xsecret = (const __m256i *) secret; const __m256i prime32 = _mm256_set1_epi32((int)XXH_PRIME32_1); size_t i; for (i=0; i < XXH_STRIPE_LEN/sizeof(__m256i); i++) { /* xacc[i] ^= (xacc[i] >> 47) */ __m256i const acc_vec = xacc[i]; __m256i const shifted = _mm256_srli_epi64 (acc_vec, 47); __m256i const data_vec = _mm256_xor_si256 (acc_vec, shifted); /* xacc[i] ^= xsecret; */ __m256i const key_vec = _mm256_loadu_si256 (xsecret+i); __m256i const data_key = _mm256_xor_si256 (data_vec, key_vec); /* xacc[i] *= XXH_PRIME32_1; */ __m256i const data_key_hi = _mm256_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1)); __m256i const prod_lo = _mm256_mul_epu32 (data_key, prime32); __m256i const prod_hi = _mm256_mul_epu32 (data_key_hi, prime32); xacc[i] = _mm256_add_epi64(prod_lo, _mm256_slli_epi64(prod_hi, 32)); } } } XXH_FORCE_INLINE XXH_TARGET_AVX2 void XXH3_initCustomSecret_avx2(void* XXH_RESTRICT customSecret, xxh_u64 seed64) { XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 31) == 0); XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE / sizeof(__m256i)) == 6); XXH_STATIC_ASSERT(XXH_SEC_ALIGN <= 64); (void)(&XXH_writeLE64); XXH_PREFETCH(customSecret); { __m256i const seed = _mm256_set_epi64x(-(xxh_i64)seed64, (xxh_i64)seed64, -(xxh_i64)seed64, (xxh_i64)seed64); XXH_ALIGN(64) const __m256i* const src = (const __m256i*) XXH3_kSecret; XXH_ALIGN(64) __m256i* dest = ( __m256i*) customSecret; # if defined(__GNUC__) || defined(__clang__) /* * On GCC & Clang, marking 'dest' as modified will cause the compiler: * - do not extract the secret from sse registers in the internal loop * - use less common registers, and avoid pushing these reg into stack */ XXH_COMPILER_GUARD(dest); # endif /* GCC -O2 need unroll loop manually */ dest[0] = _mm256_add_epi64(_mm256_stream_load_si256(src+0), seed); dest[1] = _mm256_add_epi64(_mm256_stream_load_si256(src+1), seed); dest[2] = _mm256_add_epi64(_mm256_stream_load_si256(src+2), seed); dest[3] = _mm256_add_epi64(_mm256_stream_load_si256(src+3), seed); dest[4] = _mm256_add_epi64(_mm256_stream_load_si256(src+4), seed); dest[5] = _mm256_add_epi64(_mm256_stream_load_si256(src+5), seed); } } #endif /* x86dispatch always generates SSE2 */ #if (XXH_VECTOR == XXH_SSE2) || defined(XXH_X86DISPATCH) #ifndef XXH_TARGET_SSE2 # define XXH_TARGET_SSE2 /* disable attribute target */ #endif XXH_FORCE_INLINE XXH_TARGET_SSE2 void XXH3_accumulate_512_sse2( void* XXH_RESTRICT acc, const void* XXH_RESTRICT input, const void* XXH_RESTRICT secret) { /* SSE2 is just a half-scale version of the AVX2 version. */ XXH_ASSERT((((size_t)acc) & 15) == 0); { XXH_ALIGN(16) __m128i* const xacc = (__m128i *) acc; /* Unaligned. This is mainly for pointer arithmetic, and because * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */ const __m128i* const xinput = (const __m128i *) input; /* Unaligned. This is mainly for pointer arithmetic, and because * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */ const __m128i* const xsecret = (const __m128i *) secret; size_t i; for (i=0; i < XXH_STRIPE_LEN/sizeof(__m128i); i++) { /* data_vec = xinput[i]; */ __m128i const data_vec = _mm_loadu_si128 (xinput+i); /* key_vec = xsecret[i]; */ __m128i const key_vec = _mm_loadu_si128 (xsecret+i); /* data_key = data_vec ^ key_vec; */ __m128i const data_key = _mm_xor_si128 (data_vec, key_vec); /* data_key_lo = data_key >> 32; */ __m128i const data_key_lo = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1)); /* product = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */ __m128i const product = _mm_mul_epu32 (data_key, data_key_lo); /* xacc[i] += swap(data_vec); */ __m128i const data_swap = _mm_shuffle_epi32(data_vec, _MM_SHUFFLE(1,0,3,2)); __m128i const sum = _mm_add_epi64(xacc[i], data_swap); /* xacc[i] += product; */ xacc[i] = _mm_add_epi64(product, sum); } } } XXH_FORCE_INLINE XXH_TARGET_SSE2 void XXH3_scrambleAcc_sse2(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret) { XXH_ASSERT((((size_t)acc) & 15) == 0); { XXH_ALIGN(16) __m128i* const xacc = (__m128i*) acc; /* Unaligned. This is mainly for pointer arithmetic, and because * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */ const __m128i* const xsecret = (const __m128i *) secret; const __m128i prime32 = _mm_set1_epi32((int)XXH_PRIME32_1); size_t i; for (i=0; i < XXH_STRIPE_LEN/sizeof(__m128i); i++) { /* xacc[i] ^= (xacc[i] >> 47) */ __m128i const acc_vec = xacc[i]; __m128i const shifted = _mm_srli_epi64 (acc_vec, 47); __m128i const data_vec = _mm_xor_si128 (acc_vec, shifted); /* xacc[i] ^= xsecret[i]; */ __m128i const key_vec = _mm_loadu_si128 (xsecret+i); __m128i const data_key = _mm_xor_si128 (data_vec, key_vec); /* xacc[i] *= XXH_PRIME32_1; */ __m128i const data_key_hi = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1)); __m128i const prod_lo = _mm_mul_epu32 (data_key, prime32); __m128i const prod_hi = _mm_mul_epu32 (data_key_hi, prime32); xacc[i] = _mm_add_epi64(prod_lo, _mm_slli_epi64(prod_hi, 32)); } } } XXH_FORCE_INLINE XXH_TARGET_SSE2 void XXH3_initCustomSecret_sse2(void* XXH_RESTRICT customSecret, xxh_u64 seed64) { XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 15) == 0); (void)(&XXH_writeLE64); { int const nbRounds = XXH_SECRET_DEFAULT_SIZE / sizeof(__m128i); # if defined(_MSC_VER) && defined(_M_IX86) && _MSC_VER < 1900 // MSVC 32bit mode does not support _mm_set_epi64x before 2015 XXH_ALIGN(16) const xxh_i64 seed64x2[2] = { (xxh_i64)seed64, -(xxh_i64)seed64 }; __m128i const seed = _mm_load_si128((__m128i const*)seed64x2); # else __m128i const seed = _mm_set_epi64x(-(xxh_i64)seed64, (xxh_i64)seed64); # endif int i; XXH_ALIGN(64) const float* const src = (float const*) XXH3_kSecret; XXH_ALIGN(XXH_SEC_ALIGN) __m128i* dest = (__m128i*) customSecret; # if defined(__GNUC__) || defined(__clang__) /* * On GCC & Clang, marking 'dest' as modified will cause the compiler: * - do not extract the secret from sse registers in the internal loop * - use less common registers, and avoid pushing these reg into stack */ XXH_COMPILER_GUARD(dest); # endif for (i=0; i < nbRounds; ++i) { dest[i] = _mm_add_epi64(_mm_castps_si128(_mm_load_ps(src+i*4)), seed); } } } #endif #if (XXH_VECTOR == XXH_NEON) XXH_FORCE_INLINE void XXH3_accumulate_512_neon( void* XXH_RESTRICT acc, const void* XXH_RESTRICT input, const void* XXH_RESTRICT secret) { XXH_ASSERT((((size_t)acc) & 15) == 0); { XXH_ALIGN(16) uint64x2_t* const xacc = (uint64x2_t *) acc; /* We don't use a uint32x4_t pointer because it causes bus errors on ARMv7. */ uint8_t const* const xinput = (const uint8_t *) input; uint8_t const* const xsecret = (const uint8_t *) secret; size_t i; for (i=0; i < XXH_STRIPE_LEN / sizeof(uint64x2_t); i++) { /* data_vec = xinput[i]; */ uint8x16_t data_vec = vld1q_u8(xinput + (i * 16)); /* key_vec = xsecret[i]; */ uint8x16_t key_vec = vld1q_u8(xsecret + (i * 16)); uint64x2_t data_key; uint32x2_t data_key_lo, data_key_hi; /* xacc[i] += swap(data_vec); */ uint64x2_t const data64 = vreinterpretq_u64_u8(data_vec); uint64x2_t const swapped = vextq_u64(data64, data64, 1); xacc[i] = vaddq_u64 (xacc[i], swapped); /* data_key = data_vec ^ key_vec; */ data_key = vreinterpretq_u64_u8(veorq_u8(data_vec, key_vec)); /* data_key_lo = (uint32x2_t) (data_key & 0xFFFFFFFF); * data_key_hi = (uint32x2_t) (data_key >> 32); * data_key = UNDEFINED; */ XXH_SPLIT_IN_PLACE(data_key, data_key_lo, data_key_hi); /* xacc[i] += (uint64x2_t) data_key_lo * (uint64x2_t) data_key_hi; */ xacc[i] = vmlal_u32 (xacc[i], data_key_lo, data_key_hi); } } } XXH_FORCE_INLINE void XXH3_scrambleAcc_neon(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret) { XXH_ASSERT((((size_t)acc) & 15) == 0); { uint64x2_t* xacc = (uint64x2_t*) acc; uint8_t const* xsecret = (uint8_t const*) secret; uint32x2_t prime = vdup_n_u32 (XXH_PRIME32_1); size_t i; for (i=0; i < XXH_STRIPE_LEN/sizeof(uint64x2_t); i++) { /* xacc[i] ^= (xacc[i] >> 47); */ uint64x2_t acc_vec = xacc[i]; uint64x2_t shifted = vshrq_n_u64 (acc_vec, 47); uint64x2_t data_vec = veorq_u64 (acc_vec, shifted); /* xacc[i] ^= xsecret[i]; */ uint8x16_t key_vec = vld1q_u8(xsecret + (i * 16)); uint64x2_t data_key = veorq_u64(data_vec, vreinterpretq_u64_u8(key_vec)); /* xacc[i] *= XXH_PRIME32_1 */ uint32x2_t data_key_lo, data_key_hi; /* data_key_lo = (uint32x2_t) (xacc[i] & 0xFFFFFFFF); * data_key_hi = (uint32x2_t) (xacc[i] >> 32); * xacc[i] = UNDEFINED; */ XXH_SPLIT_IN_PLACE(data_key, data_key_lo, data_key_hi); { /* * prod_hi = (data_key >> 32) * XXH_PRIME32_1; * * Avoid vmul_u32 + vshll_n_u32 since Clang 6 and 7 will * incorrectly "optimize" this: * tmp = vmul_u32(vmovn_u64(a), vmovn_u64(b)); * shifted = vshll_n_u32(tmp, 32); * to this: * tmp = "vmulq_u64"(a, b); // no such thing! * shifted = vshlq_n_u64(tmp, 32); * * However, unlike SSE, Clang lacks a 64-bit multiply routine * for NEON, and it scalarizes two 64-bit multiplies instead. * * vmull_u32 has the same timing as vmul_u32, and it avoids * this bug completely. * See https://bugs.llvm.org/show_bug.cgi?id=39967 */ uint64x2_t prod_hi = vmull_u32 (data_key_hi, prime); /* xacc[i] = prod_hi << 32; */ xacc[i] = vshlq_n_u64(prod_hi, 32); /* xacc[i] += (prod_hi & 0xFFFFFFFF) * XXH_PRIME32_1; */ xacc[i] = vmlal_u32(xacc[i], data_key_lo, prime); } } } } #endif #if (XXH_VECTOR == XXH_VSX) XXH_FORCE_INLINE void XXH3_accumulate_512_vsx( void* XXH_RESTRICT acc, const void* XXH_RESTRICT input, const void* XXH_RESTRICT secret) { xxh_u64x2* const xacc = (xxh_u64x2*) acc; /* presumed aligned */ xxh_u64x2 const* const xinput = (xxh_u64x2 const*) input; /* no alignment restriction */ xxh_u64x2 const* const xsecret = (xxh_u64x2 const*) secret; /* no alignment restriction */ xxh_u64x2 const v32 = { 32, 32 }; size_t i; for (i = 0; i < XXH_STRIPE_LEN / sizeof(xxh_u64x2); i++) { /* data_vec = xinput[i]; */ xxh_u64x2 const data_vec = XXH_vec_loadu(xinput + i); /* key_vec = xsecret[i]; */ xxh_u64x2 const key_vec = XXH_vec_loadu(xsecret + i); xxh_u64x2 const data_key = data_vec ^ key_vec; /* shuffled = (data_key << 32) | (data_key >> 32); */ xxh_u32x4 const shuffled = (xxh_u32x4)vec_rl(data_key, v32); /* product = ((xxh_u64x2)data_key & 0xFFFFFFFF) * ((xxh_u64x2)shuffled & 0xFFFFFFFF); */ xxh_u64x2 const product = XXH_vec_mulo((xxh_u32x4)data_key, shuffled); xacc[i] += product; /* swap high and low halves */ #ifdef __s390x__ xacc[i] += vec_permi(data_vec, data_vec, 2); #else xacc[i] += vec_xxpermdi(data_vec, data_vec, 2); #endif } } XXH_FORCE_INLINE void XXH3_scrambleAcc_vsx(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret) { XXH_ASSERT((((size_t)acc) & 15) == 0); { xxh_u64x2* const xacc = (xxh_u64x2*) acc; const xxh_u64x2* const xsecret = (const xxh_u64x2*) secret; /* constants */ xxh_u64x2 const v32 = { 32, 32 }; xxh_u64x2 const v47 = { 47, 47 }; xxh_u32x4 const prime = { XXH_PRIME32_1, XXH_PRIME32_1, XXH_PRIME32_1, XXH_PRIME32_1 }; size_t i; for (i = 0; i < XXH_STRIPE_LEN / sizeof(xxh_u64x2); i++) { /* xacc[i] ^= (xacc[i] >> 47); */ xxh_u64x2 const acc_vec = xacc[i]; xxh_u64x2 const data_vec = acc_vec ^ (acc_vec >> v47); /* xacc[i] ^= xsecret[i]; */ xxh_u64x2 const key_vec = XXH_vec_loadu(xsecret + i); xxh_u64x2 const data_key = data_vec ^ key_vec; /* xacc[i] *= XXH_PRIME32_1 */ /* prod_lo = ((xxh_u64x2)data_key & 0xFFFFFFFF) * ((xxh_u64x2)prime & 0xFFFFFFFF); */ xxh_u64x2 const prod_even = XXH_vec_mule((xxh_u32x4)data_key, prime); /* prod_hi = ((xxh_u64x2)data_key >> 32) * ((xxh_u64x2)prime >> 32); */ xxh_u64x2 const prod_odd = XXH_vec_mulo((xxh_u32x4)data_key, prime); xacc[i] = prod_odd + (prod_even << v32); } } } #endif /* scalar variants - universal */ XXH_FORCE_INLINE void XXH3_accumulate_512_scalar(void* XXH_RESTRICT acc, const void* XXH_RESTRICT input, const void* XXH_RESTRICT secret) { XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64* const xacc = (xxh_u64*) acc; /* presumed aligned */ const xxh_u8* const xinput = (const xxh_u8*) input; /* no alignment restriction */ const xxh_u8* const xsecret = (const xxh_u8*) secret; /* no alignment restriction */ size_t i; XXH_ASSERT(((size_t)acc & (XXH_ACC_ALIGN-1)) == 0); for (i=0; i < XXH_ACC_NB; i++) { xxh_u64 const data_val = XXH_readLE64(xinput + 8*i); xxh_u64 const data_key = data_val ^ XXH_readLE64(xsecret + i*8); xacc[i ^ 1] += data_val; /* swap adjacent lanes */ xacc[i] += XXH_mult32to64(data_key & 0xFFFFFFFF, data_key >> 32); } } XXH_FORCE_INLINE void XXH3_scrambleAcc_scalar(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret) { XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64* const xacc = (xxh_u64*) acc; /* presumed aligned */ const xxh_u8* const xsecret = (const xxh_u8*) secret; /* no alignment restriction */ size_t i; XXH_ASSERT((((size_t)acc) & (XXH_ACC_ALIGN-1)) == 0); for (i=0; i < XXH_ACC_NB; i++) { xxh_u64 const key64 = XXH_readLE64(xsecret + 8*i); xxh_u64 acc64 = xacc[i]; acc64 = XXH_xorshift64(acc64, 47); acc64 ^= key64; acc64 *= XXH_PRIME32_1; xacc[i] = acc64; } } XXH_FORCE_INLINE void XXH3_initCustomSecret_scalar(void* XXH_RESTRICT customSecret, xxh_u64 seed64) { /* * We need a separate pointer for the hack below, * which requires a non-const pointer. * Any decent compiler will optimize this out otherwise. */ const xxh_u8* kSecretPtr = XXH3_kSecret; XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 15) == 0); #if defined(__clang__) && defined(__aarch64__) /* * UGLY HACK: * Clang generates a bunch of MOV/MOVK pairs for aarch64, and they are * placed sequentially, in order, at the top of the unrolled loop. * * While MOVK is great for generating constants (2 cycles for a 64-bit * constant compared to 4 cycles for LDR), long MOVK chains stall the * integer pipelines: * I L S * MOVK * MOVK * MOVK * MOVK * ADD * SUB STR * STR * By forcing loads from memory (as the asm line causes Clang to assume * that XXH3_kSecretPtr has been changed), the pipelines are used more * efficiently: * I L S * LDR * ADD LDR * SUB STR * STR * XXH3_64bits_withSeed, len == 256, Snapdragon 835 * without hack: 2654.4 MB/s * with hack: 3202.9 MB/s */ XXH_COMPILER_GUARD(kSecretPtr); #endif /* * Note: in debug mode, this overrides the asm optimization * and Clang will emit MOVK chains again. */ XXH_ASSERT(kSecretPtr == XXH3_kSecret); { int const nbRounds = XXH_SECRET_DEFAULT_SIZE / 16; int i; for (i=0; i < nbRounds; i++) { /* * The asm hack causes Clang to assume that kSecretPtr aliases with * customSecret, and on aarch64, this prevented LDP from merging two * loads together for free. Putting the loads together before the stores * properly generates LDP. */ xxh_u64 lo = XXH_readLE64(kSecretPtr + 16*i) + seed64; xxh_u64 hi = XXH_readLE64(kSecretPtr + 16*i + 8) - seed64; XXH_writeLE64((xxh_u8*)customSecret + 16*i, lo); XXH_writeLE64((xxh_u8*)customSecret + 16*i + 8, hi); } } } typedef void (*XXH3_f_accumulate_512)(void* XXH_RESTRICT, const void*, const void*); typedef void (*XXH3_f_scrambleAcc)(void* XXH_RESTRICT, const void*); typedef void (*XXH3_f_initCustomSecret)(void* XXH_RESTRICT, xxh_u64); #if (XXH_VECTOR == XXH_AVX512) #define XXH3_accumulate_512 XXH3_accumulate_512_avx512 #define XXH3_scrambleAcc XXH3_scrambleAcc_avx512 #define XXH3_initCustomSecret XXH3_initCustomSecret_avx512 #elif (XXH_VECTOR == XXH_AVX2) #define XXH3_accumulate_512 XXH3_accumulate_512_avx2 #define XXH3_scrambleAcc XXH3_scrambleAcc_avx2 #define XXH3_initCustomSecret XXH3_initCustomSecret_avx2 #elif (XXH_VECTOR == XXH_SSE2) #define XXH3_accumulate_512 XXH3_accumulate_512_sse2 #define XXH3_scrambleAcc XXH3_scrambleAcc_sse2 #define XXH3_initCustomSecret XXH3_initCustomSecret_sse2 #elif (XXH_VECTOR == XXH_NEON) #define XXH3_accumulate_512 XXH3_accumulate_512_neon #define XXH3_scrambleAcc XXH3_scrambleAcc_neon #define XXH3_initCustomSecret XXH3_initCustomSecret_scalar #elif (XXH_VECTOR == XXH_VSX) #define XXH3_accumulate_512 XXH3_accumulate_512_vsx #define XXH3_scrambleAcc XXH3_scrambleAcc_vsx #define XXH3_initCustomSecret XXH3_initCustomSecret_scalar #else /* scalar */ #define XXH3_accumulate_512 XXH3_accumulate_512_scalar #define XXH3_scrambleAcc XXH3_scrambleAcc_scalar #define XXH3_initCustomSecret XXH3_initCustomSecret_scalar #endif #ifndef XXH_PREFETCH_DIST # ifdef __clang__ # define XXH_PREFETCH_DIST 320 # else # if (XXH_VECTOR == XXH_AVX512) # define XXH_PREFETCH_DIST 512 # else # define XXH_PREFETCH_DIST 384 # endif # endif /* __clang__ */ #endif /* XXH_PREFETCH_DIST */ /* * XXH3_accumulate() * Loops over XXH3_accumulate_512(). * Assumption: nbStripes will not overflow the secret size */ XXH_FORCE_INLINE void XXH3_accumulate( xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT input, const xxh_u8* XXH_RESTRICT secret, size_t nbStripes, XXH3_f_accumulate_512 f_acc512) { size_t n; for (n = 0; n < nbStripes; n++ ) { const xxh_u8* const in = input + n*XXH_STRIPE_LEN; XXH_PREFETCH(in + XXH_PREFETCH_DIST); f_acc512(acc, in, secret + n*XXH_SECRET_CONSUME_RATE); } } XXH_FORCE_INLINE void XXH3_hashLong_internal_loop(xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT input, size_t len, const xxh_u8* XXH_RESTRICT secret, size_t secretSize, XXH3_f_accumulate_512 f_acc512, XXH3_f_scrambleAcc f_scramble) { size_t const nbStripesPerBlock = (secretSize - XXH_STRIPE_LEN) / XXH_SECRET_CONSUME_RATE; size_t const block_len = XXH_STRIPE_LEN * nbStripesPerBlock; size_t const nb_blocks = (len - 1) / block_len; size_t n; XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); for (n = 0; n < nb_blocks; n++) { XXH3_accumulate(acc, input + n*block_len, secret, nbStripesPerBlock, f_acc512); f_scramble(acc, secret + secretSize - XXH_STRIPE_LEN); } /* last partial block */ XXH_ASSERT(len > XXH_STRIPE_LEN); { size_t const nbStripes = ((len - 1) - (block_len * nb_blocks)) / XXH_STRIPE_LEN; XXH_ASSERT(nbStripes <= (secretSize / XXH_SECRET_CONSUME_RATE)); XXH3_accumulate(acc, input + nb_blocks*block_len, secret, nbStripes, f_acc512); /* last stripe */ { const xxh_u8* const p = input + len - XXH_STRIPE_LEN; #define XXH_SECRET_LASTACC_START 7 /* not aligned on 8, last secret is different from acc & scrambler */ f_acc512(acc, p, secret + secretSize - XXH_STRIPE_LEN - XXH_SECRET_LASTACC_START); } } } XXH_FORCE_INLINE xxh_u64 XXH3_mix2Accs(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secret) { return XXH3_mul128_fold64( acc[0] ^ XXH_readLE64(secret), acc[1] ^ XXH_readLE64(secret+8) ); } static XXH64_hash_t XXH3_mergeAccs(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secret, xxh_u64 start) { xxh_u64 result64 = start; size_t i = 0; for (i = 0; i < 4; i++) { result64 += XXH3_mix2Accs(acc+2*i, secret + 16*i); #if defined(__clang__) /* Clang */ \ && (defined(__arm__) || defined(__thumb__)) /* ARMv7 */ \ && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */ \ && !defined(XXH_ENABLE_AUTOVECTORIZE) /* Define to disable */ /* * UGLY HACK: * Prevent autovectorization on Clang ARMv7-a. Exact same problem as * the one in XXH3_len_129to240_64b. Speeds up shorter keys > 240b. * XXH3_64bits, len == 256, Snapdragon 835: * without hack: 2063.7 MB/s * with hack: 2560.7 MB/s */ XXH_COMPILER_GUARD(result64); #endif } return XXH3_avalanche(result64); } #define XXH3_INIT_ACC { XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3, \ XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1 } XXH_FORCE_INLINE XXH64_hash_t XXH3_hashLong_64b_internal(const void* XXH_RESTRICT input, size_t len, const void* XXH_RESTRICT secret, size_t secretSize, XXH3_f_accumulate_512 f_acc512, XXH3_f_scrambleAcc f_scramble) { XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC; XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, f_acc512, f_scramble); /* converge into final hash */ XXH_STATIC_ASSERT(sizeof(acc) == 64); /* do not align on 8, so that the secret is different from the accumulator */ #define XXH_SECRET_MERGEACCS_START 11 XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START); return XXH3_mergeAccs(acc, (const xxh_u8*)secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)len * XXH_PRIME64_1); } /* * It's important for performance that XXH3_hashLong is not inlined. */ XXH_NO_INLINE XXH64_hash_t XXH3_hashLong_64b_withSecret(const void* XXH_RESTRICT input, size_t len, XXH64_hash_t seed64, const xxh_u8* XXH_RESTRICT secret, size_t secretLen) { (void)seed64; return XXH3_hashLong_64b_internal(input, len, secret, secretLen, XXH3_accumulate_512, XXH3_scrambleAcc); } /* * It's important for performance that XXH3_hashLong is not inlined. * Since the function is not inlined, the compiler may not be able to understand that, * in some scenarios, its `secret` argument is actually a compile time constant. * This variant enforces that the compiler can detect that, * and uses this opportunity to streamline the generated code for better performance. */ XXH_NO_INLINE XXH64_hash_t XXH3_hashLong_64b_default(const void* XXH_RESTRICT input, size_t len, XXH64_hash_t seed64, const xxh_u8* XXH_RESTRICT secret, size_t secretLen) { (void)seed64; (void)secret; (void)secretLen; return XXH3_hashLong_64b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_accumulate_512, XXH3_scrambleAcc); } /* * XXH3_hashLong_64b_withSeed(): * Generate a custom key based on alteration of default XXH3_kSecret with the seed, * and then use this key for long mode hashing. * * This operation is decently fast but nonetheless costs a little bit of time. * Try to avoid it whenever possible (typically when seed==0). * * It's important for performance that XXH3_hashLong is not inlined. Not sure * why (uop cache maybe?), but the difference is large and easily measurable. */ XXH_FORCE_INLINE XXH64_hash_t XXH3_hashLong_64b_withSeed_internal(const void* input, size_t len, XXH64_hash_t seed, XXH3_f_accumulate_512 f_acc512, XXH3_f_scrambleAcc f_scramble, XXH3_f_initCustomSecret f_initSec) { if (seed == 0) return XXH3_hashLong_64b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret), f_acc512, f_scramble); { XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE]; f_initSec(secret, seed); return XXH3_hashLong_64b_internal(input, len, secret, sizeof(secret), f_acc512, f_scramble); } } /* * It's important for performance that XXH3_hashLong is not inlined. */ XXH_NO_INLINE XXH64_hash_t XXH3_hashLong_64b_withSeed(const void* input, size_t len, XXH64_hash_t seed, const xxh_u8* secret, size_t secretLen) { (void)secret; (void)secretLen; return XXH3_hashLong_64b_withSeed_internal(input, len, seed, XXH3_accumulate_512, XXH3_scrambleAcc, XXH3_initCustomSecret); } typedef XXH64_hash_t (*XXH3_hashLong64_f)(const void* XXH_RESTRICT, size_t, XXH64_hash_t, const xxh_u8* XXH_RESTRICT, size_t); XXH_FORCE_INLINE XXH64_hash_t XXH3_64bits_internal(const void* XXH_RESTRICT input, size_t len, XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen, XXH3_hashLong64_f f_hashLong) { XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN); /* * If an action is to be taken if `secretLen` condition is not respected, * it should be done here. * For now, it's a contract pre-condition. * Adding a check and a branch here would cost performance at every hash. * Also, note that function signature doesn't offer room to return an error. */ if (len <= 16) return XXH3_len_0to16_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, seed64); if (len <= 128) return XXH3_len_17to128_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64); if (len <= XXH3_MIDSIZE_MAX) return XXH3_len_129to240_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64); return f_hashLong(input, len, seed64, (const xxh_u8*)secret, secretLen); } /* === Public entry point === */ /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits(const void* input, size_t len) { return XXH3_64bits_internal(input, len, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_default); } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSecret(const void* input, size_t len, const void* secret, size_t secretSize) { return XXH3_64bits_internal(input, len, 0, secret, secretSize, XXH3_hashLong_64b_withSecret); } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSeed(const void* input, size_t len, XXH64_hash_t seed) { return XXH3_64bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_withSeed); } /* === XXH3 streaming === */ /* * Malloc's a pointer that is always aligned to align. * * This must be freed with `XXH_alignedFree()`. * * malloc typically guarantees 16 byte alignment on 64-bit systems and 8 byte * alignment on 32-bit. This isn't enough for the 32 byte aligned loads in AVX2 * or on 32-bit, the 16 byte aligned loads in SSE2 and NEON. * * This underalignment previously caused a rather obvious crash which went * completely unnoticed due to XXH3_createState() not actually being tested. * Credit to RedSpah for noticing this bug. * * The alignment is done manually: Functions like posix_memalign or _mm_malloc * are avoided: To maintain portability, we would have to write a fallback * like this anyways, and besides, testing for the existence of library * functions without relying on external build tools is impossible. * * The method is simple: Overallocate, manually align, and store the offset * to the original behind the returned pointer. * * Align must be a power of 2 and 8 <= align <= 128. */ static void* XXH_alignedMalloc(size_t s, size_t align) { XXH_ASSERT(align <= 128 && align >= 8); /* range check */ XXH_ASSERT((align & (align-1)) == 0); /* power of 2 */ XXH_ASSERT(s != 0 && s < (s + align)); /* empty/overflow */ { /* Overallocate to make room for manual realignment and an offset byte */ xxh_u8* base = (xxh_u8*)XXH_malloc(s + align); if (base != NULL) { /* * Get the offset needed to align this pointer. * * Even if the returned pointer is aligned, there will always be * at least one byte to store the offset to the original pointer. */ size_t offset = align - ((size_t)base & (align - 1)); /* base % align */ /* Add the offset for the now-aligned pointer */ xxh_u8* ptr = base + offset; XXH_ASSERT((size_t)ptr % align == 0); /* Store the offset immediately before the returned pointer. */ ptr[-1] = (xxh_u8)offset; return ptr; } return NULL; } } /* * Frees an aligned pointer allocated by XXH_alignedMalloc(). Don't pass * normal malloc'd pointers, XXH_alignedMalloc has a specific data layout. */ static void XXH_alignedFree(void* p) { if (p != NULL) { xxh_u8* ptr = (xxh_u8*)p; /* Get the offset byte we added in XXH_malloc. */ xxh_u8 offset = ptr[-1]; /* Free the original malloc'd pointer */ xxh_u8* base = ptr - offset; XXH_free(base); } } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH3_state_t* XXH3_createState(void) { XXH3_state_t* const state = (XXH3_state_t*)XXH_alignedMalloc(sizeof(XXH3_state_t), 64); if (state==NULL) return NULL; XXH3_INITSTATE(state); return state; } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr) { XXH_alignedFree(statePtr); return XXH_OK; } /*! @ingroup xxh3_family */ XXH_PUBLIC_API void XXH3_copyState(XXH3_state_t* dst_state, const XXH3_state_t* src_state) { memcpy(dst_state, src_state, sizeof(*dst_state)); } static void XXH3_reset_internal(XXH3_state_t* statePtr, XXH64_hash_t seed, const void* secret, size_t secretSize) { size_t const initStart = offsetof(XXH3_state_t, bufferedSize); size_t const initLength = offsetof(XXH3_state_t, nbStripesPerBlock) - initStart; XXH_ASSERT(offsetof(XXH3_state_t, nbStripesPerBlock) > initStart); XXH_ASSERT(statePtr != NULL); /* set members from bufferedSize to nbStripesPerBlock (excluded) to 0 */ memset((char*)statePtr + initStart, 0, initLength); statePtr->acc[0] = XXH_PRIME32_3; statePtr->acc[1] = XXH_PRIME64_1; statePtr->acc[2] = XXH_PRIME64_2; statePtr->acc[3] = XXH_PRIME64_3; statePtr->acc[4] = XXH_PRIME64_4; statePtr->acc[5] = XXH_PRIME32_2; statePtr->acc[6] = XXH_PRIME64_5; statePtr->acc[7] = XXH_PRIME32_1; statePtr->seed = seed; statePtr->extSecret = (const unsigned char*)secret; XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); statePtr->secretLimit = secretSize - XXH_STRIPE_LEN; statePtr->nbStripesPerBlock = statePtr->secretLimit / XXH_SECRET_CONSUME_RATE; } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset(XXH3_state_t* statePtr) { if (statePtr == NULL) return XXH_ERROR; XXH3_reset_internal(statePtr, 0, XXH3_kSecret, XXH_SECRET_DEFAULT_SIZE); return XXH_OK; } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize) { if (statePtr == NULL) return XXH_ERROR; XXH3_reset_internal(statePtr, 0, secret, secretSize); if (secret == NULL) return XXH_ERROR; if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR; return XXH_OK; } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed) { if (statePtr == NULL) return XXH_ERROR; if (seed==0) return XXH3_64bits_reset(statePtr); if (seed != statePtr->seed) XXH3_initCustomSecret(statePtr->customSecret, seed); XXH3_reset_internal(statePtr, seed, NULL, XXH_SECRET_DEFAULT_SIZE); return XXH_OK; } /* Note : when XXH3_consumeStripes() is invoked, * there must be a guarantee that at least one more byte must be consumed from input * so that the function can blindly consume all stripes using the "normal" secret segment */ XXH_FORCE_INLINE void XXH3_consumeStripes(xxh_u64* XXH_RESTRICT acc, size_t* XXH_RESTRICT nbStripesSoFarPtr, size_t nbStripesPerBlock, const xxh_u8* XXH_RESTRICT input, size_t nbStripes, const xxh_u8* XXH_RESTRICT secret, size_t secretLimit, XXH3_f_accumulate_512 f_acc512, XXH3_f_scrambleAcc f_scramble) { XXH_ASSERT(nbStripes <= nbStripesPerBlock); /* can handle max 1 scramble per invocation */ XXH_ASSERT(*nbStripesSoFarPtr < nbStripesPerBlock); if (nbStripesPerBlock - *nbStripesSoFarPtr <= nbStripes) { /* need a scrambling operation */ size_t const nbStripesToEndofBlock = nbStripesPerBlock - *nbStripesSoFarPtr; size_t const nbStripesAfterBlock = nbStripes - nbStripesToEndofBlock; XXH3_accumulate(acc, input, secret + nbStripesSoFarPtr[0] * XXH_SECRET_CONSUME_RATE, nbStripesToEndofBlock, f_acc512); f_scramble(acc, secret + secretLimit); XXH3_accumulate(acc, input + nbStripesToEndofBlock * XXH_STRIPE_LEN, secret, nbStripesAfterBlock, f_acc512); *nbStripesSoFarPtr = nbStripesAfterBlock; } else { XXH3_accumulate(acc, input, secret + nbStripesSoFarPtr[0] * XXH_SECRET_CONSUME_RATE, nbStripes, f_acc512); *nbStripesSoFarPtr += nbStripes; } } /* * Both XXH3_64bits_update and XXH3_128bits_update use this routine. */ XXH_FORCE_INLINE XXH_errorcode XXH3_update(XXH3_state_t* state, const xxh_u8* input, size_t len, XXH3_f_accumulate_512 f_acc512, XXH3_f_scrambleAcc f_scramble) { if (input==NULL) #if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1) return XXH_OK; #else return XXH_ERROR; #endif { const xxh_u8* const bEnd = input + len; const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret; state->totalLen += len; XXH_ASSERT(state->bufferedSize <= XXH3_INTERNALBUFFER_SIZE); if (state->bufferedSize + len <= XXH3_INTERNALBUFFER_SIZE) { /* fill in tmp buffer */ XXH_memcpy(state->buffer + state->bufferedSize, input, len); state->bufferedSize += (XXH32_hash_t)len; return XXH_OK; } /* total input is now > XXH3_INTERNALBUFFER_SIZE */ #define XXH3_INTERNALBUFFER_STRIPES (XXH3_INTERNALBUFFER_SIZE / XXH_STRIPE_LEN) XXH_STATIC_ASSERT(XXH3_INTERNALBUFFER_SIZE % XXH_STRIPE_LEN == 0); /* clean multiple */ /* * Internal buffer is partially filled (always, except at beginning) * Complete it, then consume it. */ if (state->bufferedSize) { size_t const loadSize = XXH3_INTERNALBUFFER_SIZE - state->bufferedSize; XXH_memcpy(state->buffer + state->bufferedSize, input, loadSize); input += loadSize; XXH3_consumeStripes(state->acc, &state->nbStripesSoFar, state->nbStripesPerBlock, state->buffer, XXH3_INTERNALBUFFER_STRIPES, secret, state->secretLimit, f_acc512, f_scramble); state->bufferedSize = 0; } XXH_ASSERT(input < bEnd); /* Consume input by a multiple of internal buffer size */ if (input+XXH3_INTERNALBUFFER_SIZE < bEnd) { const xxh_u8* const limit = bEnd - XXH3_INTERNALBUFFER_SIZE; do { XXH3_consumeStripes(state->acc, &state->nbStripesSoFar, state->nbStripesPerBlock, input, XXH3_INTERNALBUFFER_STRIPES, secret, state->secretLimit, f_acc512, f_scramble); input += XXH3_INTERNALBUFFER_SIZE; } while (inputbuffer + sizeof(state->buffer) - XXH_STRIPE_LEN, input - XXH_STRIPE_LEN, XXH_STRIPE_LEN); } XXH_ASSERT(input < bEnd); /* Some remaining input (always) : buffer it */ XXH_memcpy(state->buffer, input, (size_t)(bEnd-input)); state->bufferedSize = (XXH32_hash_t)(bEnd-input); } return XXH_OK; } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH_errorcode XXH3_64bits_update(XXH3_state_t* state, const void* input, size_t len) { return XXH3_update(state, (const xxh_u8*)input, len, XXH3_accumulate_512, XXH3_scrambleAcc); } XXH_FORCE_INLINE void XXH3_digest_long (XXH64_hash_t* acc, const XXH3_state_t* state, const unsigned char* secret) { /* * Digest on a local copy. This way, the state remains unaltered, and it can * continue ingesting more input afterwards. */ memcpy(acc, state->acc, sizeof(state->acc)); if (state->bufferedSize >= XXH_STRIPE_LEN) { size_t const nbStripes = (state->bufferedSize - 1) / XXH_STRIPE_LEN; size_t nbStripesSoFar = state->nbStripesSoFar; XXH3_consumeStripes(acc, &nbStripesSoFar, state->nbStripesPerBlock, state->buffer, nbStripes, secret, state->secretLimit, XXH3_accumulate_512, XXH3_scrambleAcc); /* last stripe */ XXH3_accumulate_512(acc, state->buffer + state->bufferedSize - XXH_STRIPE_LEN, secret + state->secretLimit - XXH_SECRET_LASTACC_START); } else { /* bufferedSize < XXH_STRIPE_LEN */ xxh_u8 lastStripe[XXH_STRIPE_LEN]; size_t const catchupSize = XXH_STRIPE_LEN - state->bufferedSize; XXH_ASSERT(state->bufferedSize > 0); /* there is always some input buffered */ memcpy(lastStripe, state->buffer + sizeof(state->buffer) - catchupSize, catchupSize); memcpy(lastStripe + catchupSize, state->buffer, state->bufferedSize); XXH3_accumulate_512(acc, lastStripe, secret + state->secretLimit - XXH_SECRET_LASTACC_START); } } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (const XXH3_state_t* state) { const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret; if (state->totalLen > XXH3_MIDSIZE_MAX) { XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB]; XXH3_digest_long(acc, state, secret); return XXH3_mergeAccs(acc, secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)state->totalLen * XXH_PRIME64_1); } /* totalLen <= XXH3_MIDSIZE_MAX: digesting a short input */ if (state->seed) return XXH3_64bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed); return XXH3_64bits_withSecret(state->buffer, (size_t)(state->totalLen), secret, state->secretLimit + XXH_STRIPE_LEN); } #define XXH_MIN(x, y) (((x) > (y)) ? (y) : (x)) /*! @ingroup xxh3_family */ XXH_PUBLIC_API void XXH3_generateSecret(void* secretBuffer, const void* customSeed, size_t customSeedSize) { XXH_ASSERT(secretBuffer != NULL); if (customSeedSize == 0) { memcpy(secretBuffer, XXH3_kSecret, XXH_SECRET_DEFAULT_SIZE); return; } XXH_ASSERT(customSeed != NULL); { size_t const segmentSize = sizeof(XXH128_hash_t); size_t const nbSegments = XXH_SECRET_DEFAULT_SIZE / segmentSize; XXH128_canonical_t scrambler; XXH64_hash_t seeds[12]; size_t segnb; XXH_ASSERT(nbSegments == 12); XXH_ASSERT(segmentSize * nbSegments == XXH_SECRET_DEFAULT_SIZE); /* exact multiple */ XXH128_canonicalFromHash(&scrambler, XXH128(customSeed, customSeedSize, 0)); /* * Copy customSeed to seeds[], truncating or repeating as necessary. */ { size_t toFill = XXH_MIN(customSeedSize, sizeof(seeds)); size_t filled = toFill; memcpy(seeds, customSeed, toFill); while (filled < sizeof(seeds)) { toFill = XXH_MIN(filled, sizeof(seeds) - filled); memcpy((char*)seeds + filled, seeds, toFill); filled += toFill; } } /* generate secret */ memcpy(secretBuffer, &scrambler, sizeof(scrambler)); for (segnb=1; segnb < nbSegments; segnb++) { size_t const segmentStart = segnb * segmentSize; XXH128_canonical_t segment; XXH128_canonicalFromHash(&segment, XXH128(&scrambler, sizeof(scrambler), XXH_readLE64(seeds + segnb) + segnb) ); memcpy((char*)secretBuffer + segmentStart, &segment, sizeof(segment)); } } } /* ========================================== * XXH3 128 bits (a.k.a XXH128) * ========================================== * XXH3's 128-bit variant has better mixing and strength than the 64-bit variant, * even without counting the significantly larger output size. * * For example, extra steps are taken to avoid the seed-dependent collisions * in 17-240 byte inputs (See XXH3_mix16B and XXH128_mix32B). * * This strength naturally comes at the cost of some speed, especially on short * lengths. Note that longer hashes are about as fast as the 64-bit version * due to it using only a slight modification of the 64-bit loop. * * XXH128 is also more oriented towards 64-bit machines. It is still extremely * fast for a _128-bit_ hash on 32-bit (it usually clears XXH64). */ XXH_FORCE_INLINE XXH128_hash_t XXH3_len_1to3_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed) { /* A doubled version of 1to3_64b with different constants. */ XXH_ASSERT(input != NULL); XXH_ASSERT(1 <= len && len <= 3); XXH_ASSERT(secret != NULL); /* * len = 1: combinedl = { input[0], 0x01, input[0], input[0] } * len = 2: combinedl = { input[1], 0x02, input[0], input[1] } * len = 3: combinedl = { input[2], 0x03, input[0], input[1] } */ { xxh_u8 const c1 = input[0]; xxh_u8 const c2 = input[len >> 1]; xxh_u8 const c3 = input[len - 1]; xxh_u32 const combinedl = ((xxh_u32)c1 <<16) | ((xxh_u32)c2 << 24) | ((xxh_u32)c3 << 0) | ((xxh_u32)len << 8); xxh_u32 const combinedh = XXH_rotl32(XXH_swap32(combinedl), 13); xxh_u64 const bitflipl = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed; xxh_u64 const bitfliph = (XXH_readLE32(secret+8) ^ XXH_readLE32(secret+12)) - seed; xxh_u64 const keyed_lo = (xxh_u64)combinedl ^ bitflipl; xxh_u64 const keyed_hi = (xxh_u64)combinedh ^ bitfliph; XXH128_hash_t h128; h128.low64 = XXH64_avalanche(keyed_lo); h128.high64 = XXH64_avalanche(keyed_hi); return h128; } } XXH_FORCE_INLINE XXH128_hash_t XXH3_len_4to8_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed) { XXH_ASSERT(input != NULL); XXH_ASSERT(secret != NULL); XXH_ASSERT(4 <= len && len <= 8); seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32; { xxh_u32 const input_lo = XXH_readLE32(input); xxh_u32 const input_hi = XXH_readLE32(input + len - 4); xxh_u64 const input_64 = input_lo + ((xxh_u64)input_hi << 32); xxh_u64 const bitflip = (XXH_readLE64(secret+16) ^ XXH_readLE64(secret+24)) + seed; xxh_u64 const keyed = input_64 ^ bitflip; /* Shift len to the left to ensure it is even, this avoids even multiplies. */ XXH128_hash_t m128 = XXH_mult64to128(keyed, XXH_PRIME64_1 + (len << 2)); m128.high64 += (m128.low64 << 1); m128.low64 ^= (m128.high64 >> 3); m128.low64 = XXH_xorshift64(m128.low64, 35); m128.low64 *= 0x9FB21C651E98DF25ULL; m128.low64 = XXH_xorshift64(m128.low64, 28); m128.high64 = XXH3_avalanche(m128.high64); return m128; } } XXH_FORCE_INLINE XXH128_hash_t XXH3_len_9to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed) { XXH_ASSERT(input != NULL); XXH_ASSERT(secret != NULL); XXH_ASSERT(9 <= len && len <= 16); { xxh_u64 const bitflipl = (XXH_readLE64(secret+32) ^ XXH_readLE64(secret+40)) - seed; xxh_u64 const bitfliph = (XXH_readLE64(secret+48) ^ XXH_readLE64(secret+56)) + seed; xxh_u64 const input_lo = XXH_readLE64(input); xxh_u64 input_hi = XXH_readLE64(input + len - 8); XXH128_hash_t m128 = XXH_mult64to128(input_lo ^ input_hi ^ bitflipl, XXH_PRIME64_1); /* * Put len in the middle of m128 to ensure that the length gets mixed to * both the low and high bits in the 128x64 multiply below. */ m128.low64 += (xxh_u64)(len - 1) << 54; input_hi ^= bitfliph; /* * Add the high 32 bits of input_hi to the high 32 bits of m128, then * add the long product of the low 32 bits of input_hi and XXH_PRIME32_2 to * the high 64 bits of m128. * * The best approach to this operation is different on 32-bit and 64-bit. */ if (sizeof(void *) < sizeof(xxh_u64)) { /* 32-bit */ /* * 32-bit optimized version, which is more readable. * * On 32-bit, it removes an ADC and delays a dependency between the two * halves of m128.high64, but it generates an extra mask on 64-bit. */ m128.high64 += (input_hi & 0xFFFFFFFF00000000ULL) + XXH_mult32to64((xxh_u32)input_hi, XXH_PRIME32_2); } else { /* * 64-bit optimized (albeit more confusing) version. * * Uses some properties of addition and multiplication to remove the mask: * * Let: * a = input_hi.lo = (input_hi & 0x00000000FFFFFFFF) * b = input_hi.hi = (input_hi & 0xFFFFFFFF00000000) * c = XXH_PRIME32_2 * * a + (b * c) * Inverse Property: x + y - x == y * a + (b * (1 + c - 1)) * Distributive Property: x * (y + z) == (x * y) + (x * z) * a + (b * 1) + (b * (c - 1)) * Identity Property: x * 1 == x * a + b + (b * (c - 1)) * * Substitute a, b, and c: * input_hi.hi + input_hi.lo + ((xxh_u64)input_hi.lo * (XXH_PRIME32_2 - 1)) * * Since input_hi.hi + input_hi.lo == input_hi, we get this: * input_hi + ((xxh_u64)input_hi.lo * (XXH_PRIME32_2 - 1)) */ m128.high64 += input_hi + XXH_mult32to64((xxh_u32)input_hi, XXH_PRIME32_2 - 1); } /* m128 ^= XXH_swap64(m128 >> 64); */ m128.low64 ^= XXH_swap64(m128.high64); { /* 128x64 multiply: h128 = m128 * XXH_PRIME64_2; */ XXH128_hash_t h128 = XXH_mult64to128(m128.low64, XXH_PRIME64_2); h128.high64 += m128.high64 * XXH_PRIME64_2; h128.low64 = XXH3_avalanche(h128.low64); h128.high64 = XXH3_avalanche(h128.high64); return h128; } } } /* * Assumption: `secret` size is >= XXH3_SECRET_SIZE_MIN */ XXH_FORCE_INLINE XXH128_hash_t XXH3_len_0to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed) { XXH_ASSERT(len <= 16); { if (len > 8) return XXH3_len_9to16_128b(input, len, secret, seed); if (len >= 4) return XXH3_len_4to8_128b(input, len, secret, seed); if (len) return XXH3_len_1to3_128b(input, len, secret, seed); { XXH128_hash_t h128; xxh_u64 const bitflipl = XXH_readLE64(secret+64) ^ XXH_readLE64(secret+72); xxh_u64 const bitfliph = XXH_readLE64(secret+80) ^ XXH_readLE64(secret+88); h128.low64 = XXH64_avalanche(seed ^ bitflipl); h128.high64 = XXH64_avalanche( seed ^ bitfliph); return h128; } } } /* * A bit slower than XXH3_mix16B, but handles multiply by zero better. */ XXH_FORCE_INLINE XXH128_hash_t XXH128_mix32B(XXH128_hash_t acc, const xxh_u8* input_1, const xxh_u8* input_2, const xxh_u8* secret, XXH64_hash_t seed) { acc.low64 += XXH3_mix16B (input_1, secret+0, seed); acc.low64 ^= XXH_readLE64(input_2) + XXH_readLE64(input_2 + 8); acc.high64 += XXH3_mix16B (input_2, secret+16, seed); acc.high64 ^= XXH_readLE64(input_1) + XXH_readLE64(input_1 + 8); return acc; } XXH_FORCE_INLINE XXH128_hash_t XXH3_len_17to128_128b(const xxh_u8* XXH_RESTRICT input, size_t len, const xxh_u8* XXH_RESTRICT secret, size_t secretSize, XXH64_hash_t seed) { XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize; XXH_ASSERT(16 < len && len <= 128); { XXH128_hash_t acc; acc.low64 = len * XXH_PRIME64_1; acc.high64 = 0; if (len > 32) { if (len > 64) { if (len > 96) { acc = XXH128_mix32B(acc, input+48, input+len-64, secret+96, seed); } acc = XXH128_mix32B(acc, input+32, input+len-48, secret+64, seed); } acc = XXH128_mix32B(acc, input+16, input+len-32, secret+32, seed); } acc = XXH128_mix32B(acc, input, input+len-16, secret, seed); { XXH128_hash_t h128; h128.low64 = acc.low64 + acc.high64; h128.high64 = (acc.low64 * XXH_PRIME64_1) + (acc.high64 * XXH_PRIME64_4) + ((len - seed) * XXH_PRIME64_2); h128.low64 = XXH3_avalanche(h128.low64); h128.high64 = (XXH64_hash_t)0 - XXH3_avalanche(h128.high64); return h128; } } } XXH_NO_INLINE XXH128_hash_t XXH3_len_129to240_128b(const xxh_u8* XXH_RESTRICT input, size_t len, const xxh_u8* XXH_RESTRICT secret, size_t secretSize, XXH64_hash_t seed) { XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize; XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX); { XXH128_hash_t acc; int const nbRounds = (int)len / 32; int i; acc.low64 = len * XXH_PRIME64_1; acc.high64 = 0; for (i=0; i<4; i++) { acc = XXH128_mix32B(acc, input + (32 * i), input + (32 * i) + 16, secret + (32 * i), seed); } acc.low64 = XXH3_avalanche(acc.low64); acc.high64 = XXH3_avalanche(acc.high64); XXH_ASSERT(nbRounds >= 4); for (i=4 ; i < nbRounds; i++) { acc = XXH128_mix32B(acc, input + (32 * i), input + (32 * i) + 16, secret + XXH3_MIDSIZE_STARTOFFSET + (32 * (i - 4)), seed); } /* last bytes */ acc = XXH128_mix32B(acc, input + len - 16, input + len - 32, secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET - 16, 0ULL - seed); { XXH128_hash_t h128; h128.low64 = acc.low64 + acc.high64; h128.high64 = (acc.low64 * XXH_PRIME64_1) + (acc.high64 * XXH_PRIME64_4) + ((len - seed) * XXH_PRIME64_2); h128.low64 = XXH3_avalanche(h128.low64); h128.high64 = (XXH64_hash_t)0 - XXH3_avalanche(h128.high64); return h128; } } } XXH_FORCE_INLINE XXH128_hash_t XXH3_hashLong_128b_internal(const void* XXH_RESTRICT input, size_t len, const xxh_u8* XXH_RESTRICT secret, size_t secretSize, XXH3_f_accumulate_512 f_acc512, XXH3_f_scrambleAcc f_scramble) { XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC; XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, secret, secretSize, f_acc512, f_scramble); /* converge into final hash */ XXH_STATIC_ASSERT(sizeof(acc) == 64); XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START); { XXH128_hash_t h128; h128.low64 = XXH3_mergeAccs(acc, secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)len * XXH_PRIME64_1); h128.high64 = XXH3_mergeAccs(acc, secret + secretSize - sizeof(acc) - XXH_SECRET_MERGEACCS_START, ~((xxh_u64)len * XXH_PRIME64_2)); return h128; } } /* * It's important for performance that XXH3_hashLong is not inlined. */ XXH_NO_INLINE XXH128_hash_t XXH3_hashLong_128b_default(const void* XXH_RESTRICT input, size_t len, XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen) { (void)seed64; (void)secret; (void)secretLen; return XXH3_hashLong_128b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_accumulate_512, XXH3_scrambleAcc); } /* * It's important for performance that XXH3_hashLong is not inlined. */ XXH_NO_INLINE XXH128_hash_t XXH3_hashLong_128b_withSecret(const void* XXH_RESTRICT input, size_t len, XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen) { (void)seed64; return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, secretLen, XXH3_accumulate_512, XXH3_scrambleAcc); } XXH_FORCE_INLINE XXH128_hash_t XXH3_hashLong_128b_withSeed_internal(const void* XXH_RESTRICT input, size_t len, XXH64_hash_t seed64, XXH3_f_accumulate_512 f_acc512, XXH3_f_scrambleAcc f_scramble, XXH3_f_initCustomSecret f_initSec) { if (seed64 == 0) return XXH3_hashLong_128b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret), f_acc512, f_scramble); { XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE]; f_initSec(secret, seed64); return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, sizeof(secret), f_acc512, f_scramble); } } /* * It's important for performance that XXH3_hashLong is not inlined. */ XXH_NO_INLINE XXH128_hash_t XXH3_hashLong_128b_withSeed(const void* input, size_t len, XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen) { (void)secret; (void)secretLen; return XXH3_hashLong_128b_withSeed_internal(input, len, seed64, XXH3_accumulate_512, XXH3_scrambleAcc, XXH3_initCustomSecret); } typedef XXH128_hash_t (*XXH3_hashLong128_f)(const void* XXH_RESTRICT, size_t, XXH64_hash_t, const void* XXH_RESTRICT, size_t); XXH_FORCE_INLINE XXH128_hash_t XXH3_128bits_internal(const void* input, size_t len, XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen, XXH3_hashLong128_f f_hl128) { XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN); /* * If an action is to be taken if `secret` conditions are not respected, * it should be done here. * For now, it's a contract pre-condition. * Adding a check and a branch here would cost performance at every hash. */ if (len <= 16) return XXH3_len_0to16_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, seed64); if (len <= 128) return XXH3_len_17to128_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64); if (len <= XXH3_MIDSIZE_MAX) return XXH3_len_129to240_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64); return f_hl128(input, len, seed64, secret, secretLen); } /* === Public XXH128 API === */ /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH128_hash_t XXH3_128bits(const void* input, size_t len) { return XXH3_128bits_internal(input, len, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_128b_default); } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSecret(const void* input, size_t len, const void* secret, size_t secretSize) { return XXH3_128bits_internal(input, len, 0, (const xxh_u8*)secret, secretSize, XXH3_hashLong_128b_withSecret); } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSeed(const void* input, size_t len, XXH64_hash_t seed) { return XXH3_128bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_128b_withSeed); } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH128_hash_t XXH128(const void* input, size_t len, XXH64_hash_t seed) { return XXH3_128bits_withSeed(input, len, seed); } /* === XXH3 128-bit streaming === */ /* * All the functions are actually the same as for 64-bit streaming variant. * The only difference is the finalization routine. */ /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset(XXH3_state_t* statePtr) { if (statePtr == NULL) return XXH_ERROR; XXH3_reset_internal(statePtr, 0, XXH3_kSecret, XXH_SECRET_DEFAULT_SIZE); return XXH_OK; } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize) { if (statePtr == NULL) return XXH_ERROR; XXH3_reset_internal(statePtr, 0, secret, secretSize); if (secret == NULL) return XXH_ERROR; if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR; return XXH_OK; } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed) { if (statePtr == NULL) return XXH_ERROR; if (seed==0) return XXH3_128bits_reset(statePtr); if (seed != statePtr->seed) XXH3_initCustomSecret(statePtr->customSecret, seed); XXH3_reset_internal(statePtr, seed, NULL, XXH_SECRET_DEFAULT_SIZE); return XXH_OK; } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH_errorcode XXH3_128bits_update(XXH3_state_t* state, const void* input, size_t len) { return XXH3_update(state, (const xxh_u8*)input, len, XXH3_accumulate_512, XXH3_scrambleAcc); } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (const XXH3_state_t* state) { const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret; if (state->totalLen > XXH3_MIDSIZE_MAX) { XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB]; XXH3_digest_long(acc, state, secret); XXH_ASSERT(state->secretLimit + XXH_STRIPE_LEN >= sizeof(acc) + XXH_SECRET_MERGEACCS_START); { XXH128_hash_t h128; h128.low64 = XXH3_mergeAccs(acc, secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)state->totalLen * XXH_PRIME64_1); h128.high64 = XXH3_mergeAccs(acc, secret + state->secretLimit + XXH_STRIPE_LEN - sizeof(acc) - XXH_SECRET_MERGEACCS_START, ~((xxh_u64)state->totalLen * XXH_PRIME64_2)); return h128; } } /* len <= XXH3_MIDSIZE_MAX : short code */ if (state->seed) return XXH3_128bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed); return XXH3_128bits_withSecret(state->buffer, (size_t)(state->totalLen), secret, state->secretLimit + XXH_STRIPE_LEN); } /* 128-bit utility functions */ #include /* memcmp, memcpy */ /* return : 1 is equal, 0 if different */ /*! @ingroup xxh3_family */ XXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2) { /* note : XXH128_hash_t is compact, it has no padding byte */ return !(memcmp(&h1, &h2, sizeof(h1))); } /* This prototype is compatible with stdlib's qsort(). * return : >0 if *h128_1 > *h128_2 * <0 if *h128_1 < *h128_2 * =0 if *h128_1 == *h128_2 */ /*! @ingroup xxh3_family */ XXH_PUBLIC_API int XXH128_cmp(const void* h128_1, const void* h128_2) { XXH128_hash_t const h1 = *(const XXH128_hash_t*)h128_1; XXH128_hash_t const h2 = *(const XXH128_hash_t*)h128_2; int const hcmp = (h1.high64 > h2.high64) - (h2.high64 > h1.high64); /* note : bets that, in most cases, hash values are different */ if (hcmp) return hcmp; return (h1.low64 > h2.low64) - (h2.low64 > h1.low64); } /*====== Canonical representation ======*/ /*! @ingroup xxh3_family */ XXH_PUBLIC_API void XXH128_canonicalFromHash(XXH128_canonical_t* dst, XXH128_hash_t hash) { XXH_STATIC_ASSERT(sizeof(XXH128_canonical_t) == sizeof(XXH128_hash_t)); if (XXH_CPU_LITTLE_ENDIAN) { hash.high64 = XXH_swap64(hash.high64); hash.low64 = XXH_swap64(hash.low64); } memcpy(dst, &hash.high64, sizeof(hash.high64)); memcpy((char*)dst + sizeof(hash.high64), &hash.low64, sizeof(hash.low64)); } /*! @ingroup xxh3_family */ XXH_PUBLIC_API XXH128_hash_t XXH128_hashFromCanonical(const XXH128_canonical_t* src) { XXH128_hash_t h; h.high64 = XXH_readBE64(src); h.low64 = XXH_readBE64(src->digest + 8); return h; } /* Pop our optimization override from above */ #if XXH_VECTOR == XXH_AVX2 /* AVX2 */ \ && defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \ && defined(__OPTIMIZE__) && !defined(__OPTIMIZE_SIZE__) /* respect -O0 and -Os */ # pragma GCC pop_options #endif #endif /* XXH_NO_LONG_LONG */ #endif /* XXH_NO_XXH3 */ /*! * @} */ #endif /* XXH_IMPLEMENTATION */ #if defined (__cplusplus) } #endif memcached-1.6.20/daemon.c0000664000175000017500000000602714302037501012040 00000000000000/* $Header: /cvsroot/wikipedia/willow/src/bin/willow/daemon.c,v 1.1 2005/05/02 19:15:21 kateturner Exp $ */ /* $NetBSD: daemon.c,v 1.9 2003/08/07 16:42:46 agc Exp $ */ /*- * Copyright (c) 1990, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #if defined __SUNPRO_C || defined __DECC || defined __HP_cc # pragma ident "@(#)$Header: /cvsroot/wikipedia/willow/src/bin/willow/daemon.c,v 1.1 2005/05/02 19:15:21 kateturner Exp $" # pragma ident "$NetBSD: daemon.c,v 1.9 2003/08/07 16:42:46 agc Exp $" #endif #include #include #include #include #include "memcached.h" int daemonize(int nochdir, int noclose) { int fd; switch (fork()) { case -1: return (-1); case 0: break; default: _exit(EXIT_SUCCESS); } if (setsid() == -1) return (-1); if (nochdir == 0) { if(chdir("/") != 0) { perror("chdir"); return (-1); } } if (noclose == 0 && (fd = open("/dev/null", O_RDWR, 0)) != -1) { if(dup2(fd, STDIN_FILENO) < 0) { perror("dup2 stdin"); goto err_cleanup; } if(dup2(fd, STDOUT_FILENO) < 0) { perror("dup2 stdout"); goto err_cleanup; } if(dup2(fd, STDERR_FILENO) < 0) { perror("dup2 stderr"); goto err_cleanup; } if(close(fd) < 0) { perror("close"); return (-1); } } return (0); err_cleanup: close(fd); return (-1); } memcached-1.6.20/assoc.h0000664000175000017500000000106414403667314011723 00000000000000/* associative array */ void assoc_init(const int hashpower_init); item *assoc_find(const char *key, const size_t nkey, const uint32_t hv); int assoc_insert(item *item, const uint32_t hv); void assoc_delete(const char *key, const size_t nkey, const uint32_t hv); int start_assoc_maintenance_thread(void); void stop_assoc_maintenance_thread(void); void assoc_start_expand(uint64_t curr_items); /* walk functions */ void *assoc_get_iterator(void); bool assoc_iterate(void *iterp, item **it); void assoc_iterate_final(void *iterp); extern unsigned int hashpower; memcached-1.6.20/configure0000775000175000017500000102626314427544303012360 00000000000000#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.71 for memcached 1.6.20. # # Report bugs to . # # # Copyright (C) 1992-1996, 1998-2017, 2020-2021 Free Software Foundation, # Inc. # # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh as_nop=: if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else $as_nop case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi # Reset variables that may have inherited troublesome values from # the environment. # IFS needs to be set, to space, tab, and newline, in precisely that order. # (If _AS_PATH_WALK were called with IFS unset, it would have the # side effect of setting IFS to empty, thus disabling word splitting.) # Quoting is to prevent editors from complaining about space-tab. as_nl=' ' export as_nl IFS=" "" $as_nl" PS1='$ ' PS2='> ' PS4='+ ' # Ensure predictable behavior from utilities with locale-dependent output. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # We cannot yet rely on "unset" to work, but we need these variables # to be unset--not just set to an empty or harmless value--now, to # avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct # also avoids known problems related to "unset" and subshell syntax # in other old shells (e.g. bash 2.01 and pdksh 5.2.14). for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH do eval test \${$as_var+y} \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done # Ensure that fds 0, 1, and 2 are open. if (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi if (exec 3>&2) ; then :; else exec 2>/dev/null; fi # The user is always right. if ${PATH_SEPARATOR+false} :; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac test -r "$as_dir$0" && as_myself=$as_dir$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Use a proper internal environment variable to ensure we don't fall # into an infinite loop, continuously re-executing ourselves. if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then _as_can_reexec=no; export _as_can_reexec; # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi # We don't want this to propagate to other subprocesses. { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="as_nop=: if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else \$as_nop case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi " as_required="as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; } exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ) then : else \$as_nop exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1 blah=\$(echo \$(echo blah)) test x\"\$blah\" = xblah || exit 1 test -x / || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 test \$(( 1 + 1 )) = 2 || exit 1" if (eval "$as_required") 2>/dev/null then : as_have_required=yes else $as_nop as_have_required=no fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null then : else $as_nop as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && as_run=a "$as_shell" -c "$as_bourne_compatible""$as_required" 2>/dev/null then : CONFIG_SHELL=$as_shell as_have_required=yes if as_run=a "$as_shell" -c "$as_bourne_compatible""$as_suggested" 2>/dev/null then : break 2 fi fi done;; esac as_found=false done IFS=$as_save_IFS if $as_found then : else $as_nop if { test -f "$SHELL" || test -f "$SHELL.exe"; } && as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null then : CONFIG_SHELL=$SHELL as_have_required=yes fi fi if test "x$CONFIG_SHELL" != x then : export CONFIG_SHELL # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi if test x$as_have_required = xno then : printf "%s\n" "$0: This script requires a shell more modern than all" printf "%s\n" "$0: the shells that I found on your system." if test ${ZSH_VERSION+y} ; then printf "%s\n" "$0: In particular, zsh $ZSH_VERSION has bugs and should" printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later." else printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and $0: memcached@googlegroups.com about your system, including $0: any error possibly output before this message. Then $0: install a modern shell, or manually run the script $0: under such a shell if you do have one." fi exit 1 fi fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL # Unset more variables known to interfere with behavior of common tools. CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS ## --------------------- ## ## M4sh Shell Functions. ## ## --------------------- ## # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_nop # --------- # Do nothing but, unlike ":", preserve the value of $?. as_fn_nop () { return $? } as_nop=as_fn_nop # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null then : eval 'as_fn_append () { eval $1+=\$2 }' else $as_nop as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null then : eval 'as_fn_arith () { as_val=$(( $* )) }' else $as_nop as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith # as_fn_nop # --------- # Do nothing but, unlike ":", preserve the value of $?. as_fn_nop () { return $? } as_nop=as_fn_nop # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi printf "%s\n" "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= ' <$as_myself | sed ' s/[$]LINENO.*/&-/ t lineno b :lineno N :loop s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ t loop s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || { printf "%s\n" "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # If we had to re-execute with $CONFIG_SHELL, we're ensured to have # already done that, so ensure we don't try to do so again and fall # in an infinite loop. This has already happened in practice. _as_can_reexec=no; export _as_can_reexec # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . "./$as_me.lineno" # Exit status is that of the last command. exit } # Determine whether it's possible to make 'echo' print without a newline. # These variables are no longer used directly by Autoconf, but are AC_SUBSTed # for compatibility with existing Makefiles. ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac # For backward compatibility with old third-party macros, we provide # the shell variables $as_echo and $as_echo_n. New code should use # AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively. as_echo='printf %s\n' as_echo_n='printf %s' rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" test -n "$DJDIR" || exec 7<&0 &1 # Name of the host. # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # # Initializations. # ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= # Identity of this package. PACKAGE_NAME='memcached' PACKAGE_TARNAME='memcached' PACKAGE_VERSION='1.6.20' PACKAGE_STRING='memcached 1.6.20' PACKAGE_BUGREPORT='memcached@googlegroups.com' PACKAGE_URL='' ac_unique_file="memcached.c" # Factoring default headers for most tests. ac_includes_default="\ #include #ifdef HAVE_STDIO_H # include #endif #ifdef HAVE_STDLIB_H # include #endif #ifdef HAVE_STRING_H # include #endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif #ifdef HAVE_STRINGS_H # include #endif #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_SYS_STAT_H # include #endif #ifdef HAVE_UNISTD_H # include #endif" ac_header_c_list= ac_subst_vars='am__EXEEXT_FALSE am__EXEEXT_TRUE LTLIBOBJS LIBOBJS BUILD_SPECIFICATIONS_FALSE BUILD_SPECIFICATIONS_TRUE XSLTPROC XML2RFC BUILD_DARWIN_PRIVS_FALSE BUILD_DARWIN_PRIVS_TRUE BUILD_FREEBSD_PRIVS_FALSE BUILD_FREEBSD_PRIVS_TRUE BUILD_OPENBSD_PRIVS_FALSE BUILD_OPENBSD_PRIVS_TRUE BUILD_LINUX_PRIVS_FALSE BUILD_LINUX_PRIVS_TRUE BUILD_SOLARIS_PRIVS_FALSE BUILD_SOLARIS_PRIVS_TRUE OPENSSL_LIBS OPENSSL_CFLAGS PKG_CONFIG_LIBDIR PKG_CONFIG_PATH PKG_CONFIG PROFILER_FLAGS PROFILER PROFILER_LDFLAGS ENABLE_SASL DTRACEFLAGS ENABLE_PROXY_URING_FALSE ENABLE_PROXY_URING_TRUE ENABLE_PROXY_FALSE ENABLE_PROXY_TRUE DISABLE_UNIX_SOCKET_FALSE DISABLE_UNIX_SOCKET_TRUE ENABLE_STATIC_FALSE ENABLE_STATIC_TRUE ENABLE_ASAN_FALSE ENABLE_ASAN_TRUE ENABLE_TLS_FALSE ENABLE_TLS_TRUE ENABLE_ARM_CRC32_FALSE ENABLE_ARM_CRC32_TRUE ENABLE_EXTSTORE_FALSE ENABLE_EXTSTORE_TRUE ENABLE_SASL_FALSE ENABLE_SASL_TRUE DTRACE_INSTRUMENT_OBJ_FALSE DTRACE_INSTRUMENT_OBJ_TRUE BUILD_DTRACE_FALSE BUILD_DTRACE_TRUE DTRACE EGREP GREP CPP DARWIN_FALSE DARWIN_TRUE am__fastdepCC_FALSE am__fastdepCC_TRUE CCDEPMODE am__nodep AMDEPBACKSLASH AMDEP_FALSE AMDEP_TRUE am__include DEPDIR OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC AM_BACKSLASH AM_DEFAULT_VERBOSITY AM_DEFAULT_V AM_V CSCOPE ETAGS CTAGS am__untar am__tar AMTAR am__leading_dot SET_MAKE AWK mkdir_p MKDIR_P INSTALL_STRIP_PROGRAM STRIP install_sh MAKEINFO AUTOHEADER AUTOMAKE AUTOCONF ACLOCAL VERSION PACKAGE CYGPATH_W am__isrc INSTALL_DATA INSTALL_SCRIPT INSTALL_PROGRAM host_os host_vendor host_cpu host build_os build_vendor build_cpu build target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir runstatedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL am__quote' ac_subst_files='' ac_user_opts=' enable_option_checking enable_silent_rules enable_dependency_tracking enable_extstore enable_seccomp enable_sasl enable_sasl_pwdb enable_tls enable_asan enable_static enable_unix_socket enable_proxy enable_proxy_uring enable_werror enable_dtrace enable_coverage enable_64bit with_libevent with_libssl enable_docs ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP PKG_CONFIG PKG_CONFIG_PATH PKG_CONFIG_LIBDIR OPENSSL_CFLAGS OPENSSL_LIBS' # Initialize some variables set by options. ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep= # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= verbose= x_includes=NONE x_libraries=NONE # Installation directory options. # These are left unexpanded so users can "make install exec_prefix=/foo" # and all the variables that are supposed to be based on exec_prefix # by default will actually change. # Use braces instead of parens because sh, perl, etc. also accept them. # (The list follows the same order as the GNU Coding Standards.) bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datarootdir='${prefix}/share' datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' runstatedir='${localstatedir}/run' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' infodir='${datarootdir}/info' htmldir='${docdir}' dvidir='${docdir}' pdfdir='${docdir}' psdir='${docdir}' libdir='${exec_prefix}/lib' localedir='${datarootdir}/locale' mandir='${datarootdir}/man' ac_prev= ac_dashdash= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval $ac_prev=\$ac_option ac_prev= continue fi case $ac_option in *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; *=) ac_optarg= ;; *) ac_optarg=yes ;; esac case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir=$ac_optarg ;; -build | --build | --buil | --bui | --bu) ac_prev=build_alias ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build_alias=$ac_optarg ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file=$ac_optarg ;; --config-cache | -C) cache_file=config.cache ;; -datadir | --datadir | --datadi | --datad) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=*) datadir=$ac_optarg ;; -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ | --dataroo | --dataro | --datar) ac_prev=datarootdir ;; -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) datarootdir=$ac_optarg ;; -disable-* | --disable-*) ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) docdir=$ac_optarg ;; -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) ac_prev=dvidir ;; -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) dvidir=$ac_optarg ;; -enable-* | --enable-*) ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=\$ac_optarg ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix=$ac_optarg ;; -gas | --gas | --ga | --g) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he | -h) ac_init_help=long ;; -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ac_init_help=recursive ;; -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ac_init_help=short ;; -host | --host | --hos | --ho) ac_prev=host_alias ;; -host=* | --host=* | --hos=* | --ho=*) host_alias=$ac_optarg ;; -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) ac_prev=htmldir ;; -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ | --ht=*) htmldir=$ac_optarg ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir=$ac_optarg ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir=$ac_optarg ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir=$ac_optarg ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir=$ac_optarg ;; -localedir | --localedir | --localedi | --localed | --locale) ac_prev=localedir ;; -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) localedir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst | --locals) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) localstatedir=$ac_optarg ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir=$ac_optarg ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c | -n) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=yes ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir=$ac_optarg ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=$ac_optarg ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix=$ac_optarg ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix=$ac_optarg ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name=$ac_optarg ;; -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) ac_prev=pdfdir ;; -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) pdfdir=$ac_optarg ;; -psdir | --psdir | --psdi | --psd | --ps) ac_prev=psdir ;; -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) psdir=$ac_optarg ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -runstatedir | --runstatedir | --runstatedi | --runstated \ | --runstate | --runstat | --runsta | --runst | --runs \ | --run | --ru | --r) ac_prev=runstatedir ;; -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \ | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \ | --run=* | --ru=* | --r=*) runstatedir=$ac_optarg ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir=$ac_optarg ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir=$ac_optarg ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site=$ac_optarg ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir=$ac_optarg ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir=$ac_optarg ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target_alias ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target_alias=$ac_optarg ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers | -V) ac_init_version=: ;; -with-* | --with-*) ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=no ;; --x) # Obsolete; use --with-x. with_x=yes ;; -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes=$ac_optarg ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; -*) as_fn_error $? "unrecognized option: \`$ac_option' Try \`$0 --help' for more information" ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. printf "%s\n" "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && printf "%s\n" "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; *) printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi # Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir runstatedir do eval ac_val=\$$ac_var # Remove trailing slashes. case $ac_val in */ ) ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" done # There might be people who depend on the old broken behavior: `$host' # used to hold the argument of --host etc. # FIXME: To remove some day. build=$build_alias host=$host_alias target=$target_alias # FIXME: To remove some day. if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi fi ac_tool_prefix= test -n "$host_alias" && ac_tool_prefix=$host_alias- test "$silent" = yes && exec 6>/dev/null ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || as_fn_error $? "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || as_fn_error $? "pwd does not report name of working directory" # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then the parent directory. ac_confdir=`$as_dirname -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` srcdir=$ac_confdir if test ! -r "$srcdir/$ac_unique_file"; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r "$srcdir/$ac_unique_file"; then test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then srcdir=. fi # Remove unnecessary trailing slashes from srcdir. # Double slashes in file names in object file debugging info # mess up M-x gdb in Emacs. case $srcdir in */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; esac for ac_var in $ac_precious_vars; do eval ac_env_${ac_var}_set=\${${ac_var}+set} eval ac_env_${ac_var}_value=\$${ac_var} eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} eval ac_cv_env_${ac_var}_value=\$${ac_var} done # # Report the --help message. # if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF \`configure' configures memcached 1.6.20 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... To assign environment variables (e.g., CC, CFLAGS...), specify them as VAR=VALUE. See below for descriptions of some of the useful variables. Defaults for the options are specified in brackets. Configuration: -h, --help display this help and exit --help=short display options specific to this package --help=recursive display the short help of all the included packages -V, --version display version information and exit -q, --quiet, --silent do not print \`checking ...' messages --cache-file=FILE cache test results in FILE [disabled] -C, --config-cache alias for \`--cache-file=config.cache' -n, --no-create do not create output files --srcdir=DIR find the sources in DIR [configure dir or \`..'] Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX] By default, \`make install' will install all the files in \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify an installation prefix other than \`$ac_default_prefix' using \`--prefix', for instance \`--prefix=\$HOME'. For better control, use the options below. Fine tuning of the installation directories: --bindir=DIR user executables [EPREFIX/bin] --sbindir=DIR system admin executables [EPREFIX/sbin] --libexecdir=DIR program executables [EPREFIX/libexec] --sysconfdir=DIR read-only single-machine data [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] --localstatedir=DIR modifiable single-machine data [PREFIX/var] --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run] --libdir=DIR object code libraries [EPREFIX/lib] --includedir=DIR C header files [PREFIX/include] --oldincludedir=DIR C header files for non-gcc [/usr/include] --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] --datadir=DIR read-only architecture-independent data [DATAROOTDIR] --infodir=DIR info documentation [DATAROOTDIR/info] --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/memcached] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF Program names: --program-prefix=PREFIX prepend PREFIX to installed program names --program-suffix=SUFFIX append SUFFIX to installed program names --program-transform-name=PROGRAM run sed PROGRAM on installed program names System types: --build=BUILD configure for building on BUILD [guessed] --host=HOST cross-compile to build programs to run on HOST [BUILD] _ACEOF fi if test -n "$ac_init_help"; then case $ac_init_help in short | recursive ) echo "Configuration of memcached 1.6.20:";; esac cat <<\_ACEOF Optional Features: --disable-option-checking ignore unrecognized --enable/--with options --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --enable-silent-rules less verbose build output (undo: "make V=1") --disable-silent-rules verbose build output (undo: "make V=0") --enable-dependency-tracking do not reject slow dependency extractors --disable-dependency-tracking speeds up one-time build --disable-extstore Disable external storage (extstore) --enable-seccomp Enable seccomp restrictions EXPERIMENTAL --enable-sasl Enable SASL authentication --enable-sasl-pwdb Enable plaintext password db --enable-tls Enable Transport Layer Security EXPERIMENTAL --enable-asan Compile with ASAN EXPERIMENTAL --enable-static Compile a statically linked binary --disable-unix-socket Disable unix domain socket --enable-proxy Enable proxy code EXPERIMENTAL --enable-proxy-uring Enable proxy io_uring code EXPERIMENTAL --enable-werror Enable -Werror --enable-dtrace Enable dtrace probes --disable-coverage Disable code coverage --enable-64bit build 64bit version --disable-docs Disable documentation generation Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-libevent=PATH Specify path to libevent installation --with-libssl=PATH Specify path to libssl installation Some influential environment variables: CC C compiler command CFLAGS C compiler flags LDFLAGS linker flags, e.g. -L if you have libraries in a nonstandard directory LIBS libraries to pass to the linker, e.g. -l CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor PKG_CONFIG path to pkg-config utility PKG_CONFIG_PATH directories to add to pkg-config's search path PKG_CONFIG_LIBDIR path overriding pkg-config's built-in search path OPENSSL_CFLAGS C compiler flags for OPENSSL, overriding pkg-config OPENSSL_LIBS linker flags for OPENSSL, overriding pkg-config Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to . _ACEOF ac_status=$? fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue test -d "$ac_dir" || { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } # Check for configure.gnu first; this name is used for a wrapper for # Metaconfig's "Configure" on case-insensitive file systems. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive elif test -f "$ac_srcdir/configure"; then echo && $SHELL "$ac_srcdir/configure" --help=recursive else printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF memcached configure 1.6.20 generated by GNU Autoconf 2.71 Copyright (C) 2021 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF exit fi ## ------------------------ ## ## Autoconf initialization. ## ## ------------------------ ## # ac_fn_c_try_compile LINENO # -------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest.beam if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext then : ac_retval=0 else $as_nop printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile # ac_fn_c_try_cpp LINENO # ---------------------- # Try to preprocess conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_cpp () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_cpp conftest.$ac_ext" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || test ! -s conftest.err } then : ac_retval=0 else $as_nop printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_cpp # ac_fn_check_decl LINENO SYMBOL VAR INCLUDES EXTRA-OPTIONS FLAG-VAR # ------------------------------------------------------------------ # Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR # accordingly. Pass EXTRA-OPTIONS to the compiler, using FLAG-VAR. ac_fn_check_decl () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack as_decl_name=`echo $2|sed 's/ *(.*//'` { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5 printf %s "checking whether $as_decl_name is declared... " >&6; } if eval test \${$3+y} then : printf %s "(cached) " >&6 else $as_nop as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'` eval ac_save_FLAGS=\$$6 as_fn_append $6 " $5" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main (void) { #ifndef $as_decl_name #ifdef __cplusplus (void) $as_decl_use; #else (void) $as_decl_name; #endif #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : eval "$3=yes" else $as_nop eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext eval $6=\$ac_save_FLAGS fi eval ac_res=\$$3 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 printf "%s\n" "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_check_decl # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in # INCLUDES, setting the cache variable VAR accordingly. ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO" then : eval "$3=yes" else $as_nop eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi eval ac_res=\$$3 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 printf "%s\n" "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile # ac_fn_c_try_link LINENO # ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || test -x conftest$ac_exeext } then : ac_retval=0 else $as_nop printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link # ac_fn_c_try_run LINENO # ---------------------- # Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that # executables *can* be run. ac_fn_c_try_run () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; } then : ac_retval=0 else $as_nop printf "%s\n" "$as_me: program exited with status $ac_status" >&5 printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run # ac_fn_c_compute_int LINENO EXPR VAR INCLUDES # -------------------------------------------- # Tries to find the compile-time value of EXPR in a program that includes # INCLUDES, setting VAR accordingly. Returns whether the value could be # computed ac_fn_c_compute_int () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if test "$cross_compiling" = yes; then # Depending upon the size, compute the lo and hi bounds. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main (void) { static int test_array [1 - 2 * !(($2) >= 0)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_lo=0 ac_mid=0 while :; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main (void) { static int test_array [1 - 2 * !(($2) <= $ac_mid)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_hi=$ac_mid; break else $as_nop as_fn_arith $ac_mid + 1 && ac_lo=$as_val if test $ac_lo -le $ac_mid; then ac_lo= ac_hi= break fi as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext done else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main (void) { static int test_array [1 - 2 * !(($2) < 0)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_hi=-1 ac_mid=-1 while :; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main (void) { static int test_array [1 - 2 * !(($2) >= $ac_mid)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_lo=$ac_mid; break else $as_nop as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val if test $ac_mid -le $ac_hi; then ac_lo= ac_hi= break fi as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext done else $as_nop ac_lo= ac_hi= fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext # Binary search between lo and hi bounds. while test "x$ac_lo" != "x$ac_hi"; do as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main (void) { static int test_array [1 - 2 * !(($2) <= $ac_mid)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_hi=$ac_mid else $as_nop as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext done case $ac_lo in #(( ?*) eval "$3=\$ac_lo"; ac_retval=0 ;; '') ac_retval=1 ;; esac else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 static long int longval (void) { return $2; } static unsigned long int ulongval (void) { return $2; } #include #include int main (void) { FILE *f = fopen ("conftest.val", "w"); if (! f) return 1; if (($2) < 0) { long int i = longval (); if (i != ($2)) return 1; fprintf (f, "%ld", i); } else { unsigned long int i = ulongval (); if (i != ($2)) return 1; fprintf (f, "%lu", i); } /* Do not output a trailing newline, as this causes \r\n confusion on some platforms. */ return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO" then : echo >>conftest.val; read $3 &5 printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : printf %s "(cached) " >&6 else $as_nop eval "$3=no" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main (void) { if (sizeof ($2)) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main (void) { if (sizeof (($2))) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : else $as_nop eval "$3=yes" fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi eval ac_res=\$$3 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 printf "%s\n" "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_type # ac_fn_c_check_func LINENO FUNC VAR # ---------------------------------- # Tests whether FUNC exists, setting the cache variable VAR accordingly ac_fn_c_check_func () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Define $2 to an innocuous variant, in case declares $2. For example, HP-UX 11i declares gettimeofday. */ #define $2 innocuous_$2 /* System header to define __stub macros and hopefully few prototypes, which can conflict with char $2 (); below. */ #include #undef $2 /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char $2 (); /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined __stub_$2 || defined __stub___$2 choke me #endif int main (void) { return $2 (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO" then : eval "$3=yes" else $as_nop eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext fi eval ac_res=\$$3 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 printf "%s\n" "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_func ac_configure_args_raw= for ac_arg do case $ac_arg in *\'*) ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append ac_configure_args_raw " '$ac_arg'" done case $ac_configure_args_raw in *$as_nl*) ac_safe_unquote= ;; *) ac_unsafe_z='|&;<>()$`\\"*?[ '' ' # This string ends in space, tab. ac_unsafe_a="$ac_unsafe_z#~" ac_safe_unquote="s/ '\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\)'/ \\1/g" ac_configure_args_raw=` printf "%s\n" "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;; esac cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by memcached $as_me 1.6.20, which was generated by GNU Autoconf 2.71. Invocation command line was $ $0$ac_configure_args_raw _ACEOF exec 5>>config.log { cat <<_ASUNAME ## --------- ## ## Platform. ## ## --------- ## hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` _ASUNAME as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac printf "%s\n" "PATH: $as_dir" done IFS=$as_save_IFS } >&5 cat >&5 <<_ACEOF ## ----------- ## ## Core tests. ## ## ----------- ## _ACEOF # Keep a trace of the command line. # Strip out --no-create and --no-recursion so they do not pile up. # Strip out --silent because we don't want to record it for future runs. # Also quote any args containing shell meta-characters. # Make two passes to allow for proper duplicate-argument suppression. ac_configure_args= ac_configure_args0= ac_configure_args1= ac_must_keep_next=false for ac_pass in 1 2 do for ac_arg do case $ac_arg in -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) as_fn_append ac_configure_args1 " '$ac_arg'" if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else case $ac_arg in *=* | --config-cache | -C | -disable-* | --disable-* \ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ | -with-* | --with-* | -without-* | --without-* | --x) case "$ac_configure_args0 " in "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; esac ;; -* ) ac_must_keep_next=true ;; esac fi as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there # would cause problems or look ugly. # WARNING: Use '\'' to represent an apostrophe within the trap. # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. trap 'exit_status=$? # Sanitize IFS. IFS=" "" $as_nl" # Save into config.log some information that might help in debugging. { echo printf "%s\n" "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( *${as_nl}ac_space=\ *) sed -n \ "s/'\''/'\''\\\\'\'''\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" ;; #( *) sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) echo printf "%s\n" "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac printf "%s\n" "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then printf "%s\n" "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac printf "%s\n" "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then printf "%s\n" "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo cat confdefs.h echo fi test "$ac_signal" != 0 && printf "%s\n" "$as_me: caught signal $ac_signal" printf "%s\n" "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h printf "%s\n" "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. if test -n "$CONFIG_SITE"; then ac_site_files="$CONFIG_SITE" elif test "x$prefix" != xNONE; then ac_site_files="$prefix/share/config.site $prefix/etc/config.site" else ac_site_files="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" fi for ac_site_file in $ac_site_files do case $ac_site_file in #( */*) : ;; #( *) : ac_site_file=./$ac_site_file ;; esac if test -f "$ac_site_file" && test -r "$ac_site_file"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See \`config.log' for more details" "$LINENO" 5; } fi done if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 printf "%s\n" "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 printf "%s\n" "$as_me: creating cache $cache_file" >&6;} >$cache_file fi # Test code for whether the C compiler supports C89 (global declarations) ac_c_conftest_c89_globals=' /* Does the compiler advertise C89 conformance? Do not test the value of __STDC__, because some compilers set it to 0 while being otherwise adequately conformant. */ #if !defined __STDC__ # error "Compiler does not advertise C89 conformance" #endif #include #include struct stat; /* Most of the following tests are stolen from RCS 5.7 src/conf.sh. */ struct buf { int x; }; struct buf * (*rcsopen) (struct buf *, struct stat *, int); static char *e (p, i) char **p; int i; { return p[i]; } static char *f (char * (*g) (char **, int), char **p, ...) { char *s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; } /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not \xHH hex character constants. These do not provoke an error unfortunately, instead are silently treated as an "x". The following induces an error, until -std is added to get proper ANSI mode. Curiously \x00 != x always comes out true, for an array size at least. It is necessary to write \x00 == 0 to get something that is true only with -std. */ int osf4_cc_array ['\''\x00'\'' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) '\''x'\'' int xlc6_cc_array[FOO(a) == '\''x'\'' ? 1 : -1]; int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; int pairnames (int, char **, int *(*)(struct buf *, struct stat *, int), int, int);' # Test code for whether the C compiler supports C89 (body of main). ac_c_conftest_c89_main=' ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]); ' # Test code for whether the C compiler supports C99 (global declarations) ac_c_conftest_c99_globals=' // Does the compiler advertise C99 conformance? #if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L # error "Compiler does not advertise C99 conformance" #endif #include extern int puts (const char *); extern int printf (const char *, ...); extern int dprintf (int, const char *, ...); extern void *malloc (size_t); // Check varargs macros. These examples are taken from C99 6.10.3.5. // dprintf is used instead of fprintf to avoid needing to declare // FILE and stderr. #define debug(...) dprintf (2, __VA_ARGS__) #define showlist(...) puts (#__VA_ARGS__) #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) static void test_varargs_macros (void) { int x = 1234; int y = 5678; debug ("Flag"); debug ("X = %d\n", x); showlist (The first, second, and third items.); report (x>y, "x is %d but y is %d", x, y); } // Check long long types. #define BIG64 18446744073709551615ull #define BIG32 4294967295ul #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) #if !BIG_OK #error "your preprocessor is broken" #endif #if BIG_OK #else #error "your preprocessor is broken" #endif static long long int bignum = -9223372036854775807LL; static unsigned long long int ubignum = BIG64; struct incomplete_array { int datasize; double data[]; }; struct named_init { int number; const wchar_t *name; double average; }; typedef const char *ccp; static inline int test_restrict (ccp restrict text) { // See if C++-style comments work. // Iterate through items via the restricted pointer. // Also check for declarations in for loops. for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i) continue; return 0; } // Check varargs and va_copy. static bool test_varargs (const char *format, ...) { va_list args; va_start (args, format); va_list args_copy; va_copy (args_copy, args); const char *str = ""; int number = 0; float fnumber = 0; while (*format) { switch (*format++) { case '\''s'\'': // string str = va_arg (args_copy, const char *); break; case '\''d'\'': // int number = va_arg (args_copy, int); break; case '\''f'\'': // float fnumber = va_arg (args_copy, double); break; default: break; } } va_end (args_copy); va_end (args); return *str && number && fnumber; } ' # Test code for whether the C compiler supports C99 (body of main). ac_c_conftest_c99_main=' // Check bool. _Bool success = false; success |= (argc != 0); // Check restrict. if (test_restrict ("String literal") == 0) success = true; char *restrict newvar = "Another string"; // Check varargs. success &= test_varargs ("s, d'\'' f .", "string", 65, 34.234); test_varargs_macros (); // Check flexible array members. struct incomplete_array *ia = malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); ia->datasize = 10; for (int i = 0; i < ia->datasize; ++i) ia->data[i] = i * 1.234; // Check named initializers. struct named_init ni = { .number = 34, .name = L"Test wide string", .average = 543.34343, }; ni.number = 58; int dynamic_array[ni.number]; dynamic_array[0] = argv[0][0]; dynamic_array[ni.number - 1] = 543; // work around unused variable warnings ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\'' || dynamic_array[ni.number - 1] != 543); ' # Test code for whether the C compiler supports C11 (global declarations) ac_c_conftest_c11_globals=' // Does the compiler advertise C11 conformance? #if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L # error "Compiler does not advertise C11 conformance" #endif // Check _Alignas. char _Alignas (double) aligned_as_double; char _Alignas (0) no_special_alignment; extern char aligned_as_int; char _Alignas (0) _Alignas (int) aligned_as_int; // Check _Alignof. enum { int_alignment = _Alignof (int), int_array_alignment = _Alignof (int[100]), char_alignment = _Alignof (char) }; _Static_assert (0 < -_Alignof (int), "_Alignof is signed"); // Check _Noreturn. int _Noreturn does_not_return (void) { for (;;) continue; } // Check _Static_assert. struct test_static_assert { int x; _Static_assert (sizeof (int) <= sizeof (long int), "_Static_assert does not work in struct"); long int y; }; // Check UTF-8 literals. #define u8 syntax error! char const utf8_literal[] = u8"happens to be ASCII" "another string"; // Check duplicate typedefs. typedef long *long_ptr; typedef long int *long_ptr; typedef long_ptr long_ptr; // Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1. struct anonymous { union { struct { int i; int j; }; struct { int k; long int l; } w; }; int m; } v1; ' # Test code for whether the C compiler supports C11 (body of main). ac_c_conftest_c11_main=' _Static_assert ((offsetof (struct anonymous, i) == offsetof (struct anonymous, w.k)), "Anonymous union alignment botch"); v1.i = 2; v1.w.k = 5; ok |= v1.i != 5; ' # Test code for whether the C compiler supports C11 (complete). ac_c_conftest_c11_program="${ac_c_conftest_c89_globals} ${ac_c_conftest_c99_globals} ${ac_c_conftest_c11_globals} int main (int argc, char **argv) { int ok = 0; ${ac_c_conftest_c89_main} ${ac_c_conftest_c99_main} ${ac_c_conftest_c11_main} return ok; } " # Test code for whether the C compiler supports C99 (complete). ac_c_conftest_c99_program="${ac_c_conftest_c89_globals} ${ac_c_conftest_c99_globals} int main (int argc, char **argv) { int ok = 0; ${ac_c_conftest_c89_main} ${ac_c_conftest_c99_main} return ok; } " # Test code for whether the C compiler supports C89 (complete). ac_c_conftest_c89_program="${ac_c_conftest_c89_globals} int main (int argc, char **argv) { int ok = 0; ${ac_c_conftest_c89_main} return ok; } " as_fn_append ac_header_c_list " stdio.h stdio_h HAVE_STDIO_H" as_fn_append ac_header_c_list " stdlib.h stdlib_h HAVE_STDLIB_H" as_fn_append ac_header_c_list " string.h string_h HAVE_STRING_H" as_fn_append ac_header_c_list " inttypes.h inttypes_h HAVE_INTTYPES_H" as_fn_append ac_header_c_list " stdint.h stdint_h HAVE_STDINT_H" as_fn_append ac_header_c_list " strings.h strings_h HAVE_STRINGS_H" as_fn_append ac_header_c_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H" as_fn_append ac_header_c_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H" as_fn_append ac_header_c_list " unistd.h unistd_h HAVE_UNISTD_H" # Auxiliary files required by this configure script. ac_aux_files="compile missing install-sh config.guess config.sub" # Locations in which to look for auxiliary files. ac_aux_dir_candidates="${srcdir}${PATH_SEPARATOR}${srcdir}/..${PATH_SEPARATOR}${srcdir}/../.." # Search for a directory containing all of the required auxiliary files, # $ac_aux_files, from the $PATH-style list $ac_aux_dir_candidates. # If we don't find one directory that contains all the files we need, # we report the set of missing files from the *first* directory in # $ac_aux_dir_candidates and give up. ac_missing_aux_files="" ac_first_candidate=: printf "%s\n" "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in $ac_aux_dir_candidates do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac as_found=: printf "%s\n" "$as_me:${as_lineno-$LINENO}: trying $as_dir" >&5 ac_aux_dir_found=yes ac_install_sh= for ac_aux in $ac_aux_files do # As a special case, if "install-sh" is required, that requirement # can be satisfied by any of "install-sh", "install.sh", or "shtool", # and $ac_install_sh is set appropriately for whichever one is found. if test x"$ac_aux" = x"install-sh" then if test -f "${as_dir}install-sh"; then printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install-sh found" >&5 ac_install_sh="${as_dir}install-sh -c" elif test -f "${as_dir}install.sh"; then printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install.sh found" >&5 ac_install_sh="${as_dir}install.sh -c" elif test -f "${as_dir}shtool"; then printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}shtool found" >&5 ac_install_sh="${as_dir}shtool install -c" else ac_aux_dir_found=no if $ac_first_candidate; then ac_missing_aux_files="${ac_missing_aux_files} install-sh" else break fi fi else if test -f "${as_dir}${ac_aux}"; then printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}${ac_aux} found" >&5 else ac_aux_dir_found=no if $ac_first_candidate; then ac_missing_aux_files="${ac_missing_aux_files} ${ac_aux}" else break fi fi fi done if test "$ac_aux_dir_found" = yes; then ac_aux_dir="$as_dir" break fi ac_first_candidate=false as_found=false done IFS=$as_save_IFS if $as_found then : else $as_nop as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5 fi # These three variables are undocumented and unsupported, # and are intended to be withdrawn in a future Autoconf release. # They can cause serious problems if a builder's source tree is in a directory # whose full name contains unusual characters. if test -f "${ac_aux_dir}config.guess"; then ac_config_guess="$SHELL ${ac_aux_dir}config.guess" fi if test -f "${ac_aux_dir}config.sub"; then ac_config_sub="$SHELL ${ac_aux_dir}config.sub" fi if test -f "$ac_aux_dir/configure"; then ac_configure="$SHELL ${ac_aux_dir}configure" fi # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in $ac_precious_vars; do eval ac_old_set=\$ac_cv_env_${ac_var}_set eval ac_new_set=\$ac_env_${ac_var}_set eval ac_old_val=\$ac_cv_env_${ac_var}_value eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 printf "%s\n" "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 printf "%s\n" "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 printf "%s\n" "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 printf "%s\n" "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 printf "%s\n" "$as_me: former value: \`$ac_old_val'" >&2;} { printf "%s\n" "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 printf "%s\n" "$as_me: current value: \`$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in *\'*) ac_arg=$ac_var=`printf "%s\n" "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run \`${MAKE-make} distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## ## Main body of script. ## ## -------------------- ## ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu # Make sure we can run config.sub. $SHELL "${ac_aux_dir}config.sub" sun4 >/dev/null 2>&1 || as_fn_error $? "cannot run $SHELL ${ac_aux_dir}config.sub" "$LINENO" 5 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 printf %s "checking build system type... " >&6; } if test ${ac_cv_build+y} then : printf %s "(cached) " >&6 else $as_nop ac_build_alias=$build_alias test "x$ac_build_alias" = x && ac_build_alias=`$SHELL "${ac_aux_dir}config.guess"` test "x$ac_build_alias" = x && as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` || as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed" "$LINENO" 5 fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 printf "%s\n" "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; esac build=$ac_cv_build ac_save_IFS=$IFS; IFS='-' set x $ac_cv_build shift build_cpu=$1 build_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: build_os=$* IFS=$ac_save_IFS case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 printf %s "checking host system type... " >&6; } if test ${ac_cv_host+y} then : printf %s "(cached) " >&6 else $as_nop if test "x$host_alias" = x; then ac_cv_host=$ac_cv_build else ac_cv_host=`$SHELL "${ac_aux_dir}config.sub" $host_alias` || as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $host_alias failed" "$LINENO" 5 fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 printf "%s\n" "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; esac host=$ac_cv_host ac_save_IFS=$IFS; IFS='-' set x $ac_cv_host shift host_cpu=$1 host_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: host_os=$* IFS=$ac_save_IFS case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac am__api_version='1.16' # Find a good install program. We prefer a C program (faster), # so one script is as good as another. But avoid the broken or # incompatible versions: # SysV /etc/install, /usr/sbin/install # SunOS /usr/etc/install # IRIX /sbin/install # AIX /bin/install # AmigaOS /C/install, which installs bootblocks on floppy discs # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag # AFS /usr/afsws/bin/install, which mishandles nonexistent args # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" # OS/2's system install, which has a completely different semantic # ./install, which can be erroneously created by make from ./install.sh. # Reject install programs that cannot install multiple files. { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 printf %s "checking for a BSD-compatible install... " >&6; } if test -z "$INSTALL"; then if test ${ac_cv_path_install+y} then : printf %s "(cached) " >&6 else $as_nop as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac # Account for fact that we put trailing slashes in our PATH walk. case $as_dir in #(( ./ | /[cC]/* | \ /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ /usr/ucb/* ) ;; *) # OSF1 and SCO ODT 3.0 have their own names for install. # Don't use installbsd from OSF since it installs stuff as root # by default. for ac_prog in ginstall scoinst install; do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext"; then if test $ac_prog = install && grep dspmsg "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then # AIX install. It has an incompatible calling convention. : elif test $ac_prog = install && grep pwplus "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then # program-specific install script used by HP pwplus--don't use. : else rm -rf conftest.one conftest.two conftest.dir echo one > conftest.one echo two > conftest.two mkdir conftest.dir if "$as_dir$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir/" && test -s conftest.one && test -s conftest.two && test -s conftest.dir/conftest.one && test -s conftest.dir/conftest.two then ac_cv_path_install="$as_dir$ac_prog$ac_exec_ext -c" break 3 fi fi fi done done ;; esac done IFS=$as_save_IFS rm -rf conftest.one conftest.two conftest.dir fi if test ${ac_cv_path_install+y}; then INSTALL=$ac_cv_path_install else # As a last resort, use the slow shell script. Don't cache a # value for INSTALL within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. INSTALL=$ac_install_sh fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 printf "%s\n" "$INSTALL" >&6; } # Use test -z because SunOS4 sh mishandles braces in ${var-val}. # It thinks the first close brace ends the variable substitution. test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 printf %s "checking whether build environment is sane... " >&6; } # Reject unsafe characters in $srcdir or the absolute working directory # name. Accept space and tab only in the latter. am_lf=' ' case `pwd` in *[\\\"\#\$\&\'\`$am_lf]*) as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;; esac case $srcdir in *[\\\"\#\$\&\'\`$am_lf\ \ ]*) as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;; esac # Do 'set' in a subshell so we don't clobber the current shell's # arguments. Must try -L first in case configure is actually a # symlink; some systems play weird games with the mod time of symlinks # (eg FreeBSD returns the mod time of the symlink's containing # directory). if ( am_has_slept=no for am_try in 1 2; do echo "timestamp, slept: $am_has_slept" > conftest.file set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` if test "$*" = "X"; then # -L didn't work. set X `ls -t "$srcdir/configure" conftest.file` fi if test "$*" != "X $srcdir/configure conftest.file" \ && test "$*" != "X conftest.file $srcdir/configure"; then # If neither matched, then we have a broken ls. This can happen # if, for instance, CONFIG_SHELL is bash and it inherits a # broken ls alias from the environment. This has actually # happened. Such a system could not be considered "sane". as_fn_error $? "ls -t appears to fail. Make sure there is not a broken alias in your environment" "$LINENO" 5 fi if test "$2" = conftest.file || test $am_try -eq 2; then break fi # Just in case. sleep 1 am_has_slept=yes done test "$2" = conftest.file ) then # Ok. : else as_fn_error $? "newly created file is older than distributed files! Check your system clock" "$LINENO" 5 fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } # If we didn't sleep, we still need to ensure time stamps of config.status and # generated files are strictly newer. am_sleep_pid= if grep 'slept: no' conftest.file >/dev/null 2>&1; then ( sleep 1 ) & am_sleep_pid=$! fi rm -f conftest.file test "$program_prefix" != NONE && program_transform_name="s&^&$program_prefix&;$program_transform_name" # Use a double $ so make ignores it. test "$program_suffix" != NONE && program_transform_name="s&\$&$program_suffix&;$program_transform_name" # Double any \ or $. # By default was `s,x,x', remove it if useless. ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' program_transform_name=`printf "%s\n" "$program_transform_name" | sed "$ac_script"` # Expand $ac_aux_dir to an absolute path. am_aux_dir=`cd "$ac_aux_dir" && pwd` if test x"${MISSING+set}" != xset; then MISSING="\${SHELL} '$am_aux_dir/missing'" fi # Use eval to expand $SHELL if eval "$MISSING --is-lightweight"; then am_missing_run="$MISSING " else am_missing_run= { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5 printf "%s\n" "$as_me: WARNING: 'missing' script is too old or missing" >&2;} fi if test x"${install_sh+set}" != xset; then case $am_aux_dir in *\ * | *\ *) install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; *) install_sh="\${SHELL} $am_aux_dir/install-sh" esac fi # Installed binaries are usually stripped using 'strip' when the user # run "make install-strip". However 'strip' might not be the right # tool to use in cross-compilation environments, therefore Automake # will honor the 'STRIP' environment variable to overrule this program. if test "$cross_compiling" != no; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. set dummy ${ac_tool_prefix}strip; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_STRIP+y} then : printf %s "(cached) " >&6 else $as_nop if test -n "$STRIP"; then ac_cv_prog_STRIP="$STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_STRIP="${ac_tool_prefix}strip" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi STRIP=$ac_cv_prog_STRIP if test -n "$STRIP"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 printf "%s\n" "$STRIP" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_STRIP"; then ac_ct_STRIP=$STRIP # Extract the first word of "strip", so it can be a program name with args. set dummy strip; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_STRIP+y} then : printf %s "(cached) " >&6 else $as_nop if test -n "$ac_ct_STRIP"; then ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_STRIP="strip" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP if test -n "$ac_ct_STRIP"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 printf "%s\n" "$ac_ct_STRIP" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_STRIP" = x; then STRIP=":" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac STRIP=$ac_ct_STRIP fi else STRIP="$ac_cv_prog_STRIP" fi fi INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a race-free mkdir -p" >&5 printf %s "checking for a race-free mkdir -p... " >&6; } if test -z "$MKDIR_P"; then if test ${ac_cv_path_mkdir+y} then : printf %s "(cached) " >&6 else $as_nop as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_prog in mkdir gmkdir; do for ac_exec_ext in '' $ac_executable_extensions; do as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext" || continue case `"$as_dir$ac_prog$ac_exec_ext" --version 2>&1` in #( 'mkdir ('*'coreutils) '* | \ 'BusyBox '* | \ 'mkdir (fileutils) '4.1*) ac_cv_path_mkdir=$as_dir$ac_prog$ac_exec_ext break 3;; esac done done done IFS=$as_save_IFS fi test -d ./--version && rmdir ./--version if test ${ac_cv_path_mkdir+y}; then MKDIR_P="$ac_cv_path_mkdir -p" else # As a last resort, use the slow shell script. Don't cache a # value for MKDIR_P within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. MKDIR_P="$ac_install_sh -d" fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 printf "%s\n" "$MKDIR_P" >&6; } for ac_prog in gawk mawk nawk awk do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_AWK+y} then : printf %s "(cached) " >&6 else $as_nop if test -n "$AWK"; then ac_cv_prog_AWK="$AWK" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AWK="$ac_prog" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi AWK=$ac_cv_prog_AWK if test -n "$AWK"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 printf "%s\n" "$AWK" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi test -n "$AWK" && break done { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 printf %s "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } set x ${MAKE-make} ac_make=`printf "%s\n" "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` if eval test \${ac_cv_prog_make_${ac_make}_set+y} then : printf %s "(cached) " >&6 else $as_nop cat >conftest.make <<\_ACEOF SHELL = /bin/sh all: @echo '@@@%%%=$(MAKE)=@@@%%%' _ACEOF # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. case `${MAKE-make} -f conftest.make 2>/dev/null` in *@@@%%%=?*=@@@%%%*) eval ac_cv_prog_make_${ac_make}_set=yes;; *) eval ac_cv_prog_make_${ac_make}_set=no;; esac rm -f conftest.make fi if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } SET_MAKE= else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } SET_MAKE="MAKE=${MAKE-make}" fi rm -rf .tst 2>/dev/null mkdir .tst 2>/dev/null if test -d .tst; then am__leading_dot=. else am__leading_dot=_ fi rmdir .tst 2>/dev/null # Check whether --enable-silent-rules was given. if test ${enable_silent_rules+y} then : enableval=$enable_silent_rules; fi case $enable_silent_rules in # ((( yes) AM_DEFAULT_VERBOSITY=0;; no) AM_DEFAULT_VERBOSITY=1;; *) AM_DEFAULT_VERBOSITY=1;; esac am_make=${MAKE-make} { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5 printf %s "checking whether $am_make supports nested variables... " >&6; } if test ${am_cv_make_support_nested_variables+y} then : printf %s "(cached) " >&6 else $as_nop if printf "%s\n" 'TRUE=$(BAR$(V)) BAR0=false BAR1=true V=1 am__doit: @$(TRUE) .PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then am_cv_make_support_nested_variables=yes else am_cv_make_support_nested_variables=no fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5 printf "%s\n" "$am_cv_make_support_nested_variables" >&6; } if test $am_cv_make_support_nested_variables = yes; then AM_V='$(V)' AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' else AM_V=$AM_DEFAULT_VERBOSITY AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY fi AM_BACKSLASH='\' if test "`cd $srcdir && pwd`" != "`pwd`"; then # Use -I$(srcdir) only when $(srcdir) != ., so that make's output # is not polluted with repeated "-I." am__isrc=' -I$(srcdir)' # test to see if srcdir already configured if test -f $srcdir/config.status; then as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5 fi fi # test whether we have cygpath if test -z "$CYGPATH_W"; then if (cygpath --version) >/dev/null 2>/dev/null; then CYGPATH_W='cygpath -w' else CYGPATH_W=echo fi fi # Define the identity of the package. PACKAGE='memcached' VERSION='1.6.20' printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h printf "%s\n" "#define VERSION \"$VERSION\"" >>confdefs.h # Some tools Automake needs. ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"} AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"} AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"} AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"} MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"} # For better backward compatibility. To be removed once Automake 1.9.x # dies out for good. For more background, see: # # mkdir_p='$(MKDIR_P)' # We need awk for the "check" target (and possibly the TAP driver). The # system "awk" is bad on some platforms. # Always define AMTAR for backward compatibility. Yes, it's still used # in the wild :-( We should find a proper way to deprecate it ... AMTAR='$${TAR-tar}' # We'll loop over all known methods to create a tar archive until one works. _am_tools='gnutar pax cpio none' am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -' # Variables for tags utilities; see am/tags.am if test -z "$CTAGS"; then CTAGS=ctags fi if test -z "$ETAGS"; then ETAGS=etags fi if test -z "$CSCOPE"; then CSCOPE=cscope fi # POSIX will say in a future version that running "rm -f" with no argument # is OK; and we want to be able to make that assumption in our Makefile # recipes. So use an aggressive probe to check that the usage we want is # actually supported "in the wild" to an acceptable degree. # See automake bug#10828. # To make any issue more visible, cause the running configure to be aborted # by default if the 'rm' program in use doesn't match our expectations; the # user can still override this though. if rm -f && rm -fr && rm -rf; then : OK; else cat >&2 <<'END' Oops! Your 'rm' program seems unable to run without file operands specified on the command line, even when the '-f' option is present. This is contrary to the behaviour of most rm programs out there, and not conforming with the upcoming POSIX standard: Please tell bug-automake@gnu.org about your system, including the value of your $PATH and any error possibly output before this message. This can help us improve future automake versions. END if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then echo 'Configuration will proceed anyway, since you have set the' >&2 echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2 echo >&2 else cat >&2 <<'END' Aborting the configuration process, to ensure you take notice of the issue. You can download and install GNU coreutils to get an 'rm' implementation that behaves properly: . If you want to complete the configuration process using your problematic 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM to "yes", and re-run configure. END as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5 fi fi ac_config_headers="$ac_config_headers config.h" ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 else $as_nop if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}gcc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 printf "%s\n" "$CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 else $as_nop if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="gcc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 printf "%s\n" "$ac_ct_CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 else $as_nop if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}cc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 printf "%s\n" "$CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 else $as_nop if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then if test "$as_dir$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@" fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 printf "%s\n" "$CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 else $as_nop if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 printf "%s\n" "$CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 else $as_nop if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="$ac_prog" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 printf "%s\n" "$ac_ct_CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}clang", so it can be a program name with args. set dummy ${ac_tool_prefix}clang; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 else $as_nop if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}clang" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 printf "%s\n" "$CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "clang", so it can be a program name with args. set dummy clang; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 else $as_nop if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="clang" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 printf "%s\n" "$ac_ct_CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi fi test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion -version; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 printf %s "checking whether the C compiler works... " >&6; } ac_link_default=`printf "%s\n" "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ac_rmfiles= for ac_file in $ac_files do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; * ) ac_rmfiles="$ac_rmfiles $ac_file";; esac done rm -f $ac_rmfiles if { { ac_try="$ac_link_default" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. for ac_file in $ac_files '' do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; [ab].out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) if test ${ac_cv_exeext+y} && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an `-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test "$ac_cv_exeext" = no && ac_cv_exeext= else $as_nop ac_file='' fi if test -z "$ac_file" then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See \`config.log' for more details" "$LINENO" 5; } else $as_nop { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 printf %s "checking for C compiler default output file name... " >&6; } { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 printf "%s\n" "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 printf %s "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : # If both `conftest.exe' and `conftest' are `present' (well, observable) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with # `rm'. for ac_file in conftest.exe conftest conftest.*; do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` break;; * ) break;; esac done else $as_nop { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest conftest$ac_cv_exeext { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 printf "%s\n" "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main (void) { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 printf %s "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "cannot run C compiled programs. If you meant to cross compile, use \`--host'. See \`config.log' for more details" "$LINENO" 5; } fi fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 printf "%s\n" "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 printf %s "checking for suffix of object files... " >&6; } if test ${ac_cv_objext+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : for ac_file in conftest.o conftest.obj conftest.*; do test -f "$ac_file" || continue; case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else $as_nop printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 printf "%s\n" "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5 printf %s "checking whether the compiler supports GNU C... " >&6; } if test ${ac_cv_c_compiler_gnu+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_compiler_gnu=yes else $as_nop ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; } ac_compiler_gnu=$ac_cv_c_compiler_gnu if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+y} ac_save_CFLAGS=$CFLAGS { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 printf %s "checking whether $CC accepts -g... " >&6; } if test ${ac_cv_prog_cc_g+y} then : printf %s "(cached) " >&6 else $as_nop ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_g=yes else $as_nop CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : else $as_nop ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 printf "%s\n" "$ac_cv_prog_cc_g" >&6; } if test $ac_test_CFLAGS; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi ac_prog_cc_stdc=no if test x$ac_prog_cc_stdc = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5 printf %s "checking for $CC option to enable C11 features... " >&6; } if test ${ac_cv_prog_cc_c11+y} then : printf %s "(cached) " >&6 else $as_nop ac_cv_prog_cc_c11=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_c_conftest_c11_program _ACEOF for ac_arg in '' -std=gnu11 do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_c11=$ac_arg fi rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c11" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi if test "x$ac_cv_prog_cc_c11" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } else $as_nop if test "x$ac_cv_prog_cc_c11" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } else $as_nop { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 printf "%s\n" "$ac_cv_prog_cc_c11" >&6; } CC="$CC $ac_cv_prog_cc_c11" fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11 ac_prog_cc_stdc=c11 fi fi if test x$ac_prog_cc_stdc = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5 printf %s "checking for $CC option to enable C99 features... " >&6; } if test ${ac_cv_prog_cc_c99+y} then : printf %s "(cached) " >&6 else $as_nop ac_cv_prog_cc_c99=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_c_conftest_c99_program _ACEOF for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99= do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_c99=$ac_arg fi rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c99" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi if test "x$ac_cv_prog_cc_c99" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } else $as_nop if test "x$ac_cv_prog_cc_c99" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } else $as_nop { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 printf "%s\n" "$ac_cv_prog_cc_c99" >&6; } CC="$CC $ac_cv_prog_cc_c99" fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99 ac_prog_cc_stdc=c99 fi fi if test x$ac_prog_cc_stdc = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5 printf %s "checking for $CC option to enable C89 features... " >&6; } if test ${ac_cv_prog_cc_c89+y} then : printf %s "(cached) " >&6 else $as_nop ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_c_conftest_c89_program _ACEOF for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi if test "x$ac_cv_prog_cc_c89" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } else $as_nop if test "x$ac_cv_prog_cc_c89" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } else $as_nop { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 printf "%s\n" "$ac_cv_prog_cc_c89" >&6; } CC="$CC $ac_cv_prog_cc_c89" fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89 ac_prog_cc_stdc=c89 fi fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5 printf %s "checking whether $CC understands -c and -o together... " >&6; } if test ${am_cv_prog_cc_c_o+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF # Make sure it works both with $CC and with simple cc. # Following AC_PROG_CC_C_O, we do the test twice because some # compilers refuse to overwrite an existing .o file with -o, # though they will create one. am_cv_prog_cc_c_o=yes for am_i in 1 2; do if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5 ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } \ && test -f conftest2.$ac_objext; then : OK else am_cv_prog_cc_c_o=no break fi done rm -f core conftest* unset am_i fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5 printf "%s\n" "$am_cv_prog_cc_c_o" >&6; } if test "$am_cv_prog_cc_c_o" != yes; then # Losing compiler, so override with the script. # FIXME: It is wrong to rewrite CC. # But if we don't then we get into trouble of one sort or another. # A longer-term fix would be to have automake use am__CC in this case, # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)" CC="$am_aux_dir/compile $CC" fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu DEPDIR="${am__leading_dot}deps" ac_config_commands="$ac_config_commands depfiles" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5 printf %s "checking whether ${MAKE-make} supports the include directive... " >&6; } cat > confinc.mk << 'END' am__doit: @echo this is the am__doit target >confinc.out .PHONY: am__doit END am__include="#" am__quote= # BSD make does it like this. echo '.include "confinc.mk" # ignored' > confmf.BSD # Other make implementations (GNU, Solaris 10, AIX) do it like this. echo 'include confinc.mk # ignored' > confmf.GNU _am_result=no for s in GNU BSD; do { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5 (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } case $?:`cat confinc.out 2>/dev/null` in #( '0:this is the am__doit target') : case $s in #( BSD) : am__include='.include' am__quote='"' ;; #( *) : am__include='include' am__quote='' ;; esac ;; #( *) : ;; esac if test "$am__include" != "#"; then _am_result="yes ($s style)" break fi done rm -f confinc.* confmf.* { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5 printf "%s\n" "${_am_result}" >&6; } # Check whether --enable-dependency-tracking was given. if test ${enable_dependency_tracking+y} then : enableval=$enable_dependency_tracking; fi if test "x$enable_dependency_tracking" != xno; then am_depcomp="$ac_aux_dir/depcomp" AMDEPBACKSLASH='\' am__nodep='_no' fi if test "x$enable_dependency_tracking" != xno; then AMDEP_TRUE= AMDEP_FALSE='#' else AMDEP_TRUE='#' AMDEP_FALSE= fi depcc="$CC" am_compiler_list= { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 printf %s "checking dependency style of $depcc... " >&6; } if test ${am_cv_CC_dependencies_compiler_type+y} then : printf %s "(cached) " >&6 else $as_nop if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named 'D' -- because '-MD' means "put the output # in D". rm -rf conftest.dir mkdir conftest.dir # Copy depcomp to subdir because otherwise we won't find it if we're # using a relative directory. cp "$am_depcomp" conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64's cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub am_cv_CC_dependencies_compiler_type=none if test "$am_compiler_list" = ""; then am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` fi am__universal=false case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with \), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo '#include "conftst'$i'.h"' >> sub/conftest.c # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with # Solaris 10 /bin/sh. echo '/* dummy */' > sub/conftst$i.h done echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf # We check with '-c' and '-o' for the sake of the "dashmstdout" # mode. It turns out that the SunPro C++ compiler does not properly # handle '-M -o', and we need to detect this. Also, some Intel # versions had trouble with output in subdirs. am__obj=sub/conftest.${OBJEXT-o} am__minus_obj="-o $am__obj" case $depmode in gcc) # This depmode causes a compiler race in universal mode. test "$am__universal" = false || continue ;; nosideeffect) # After this tag, mechanisms are not by side-effect, so they'll # only be used when explicitly requested. if test "x$enable_dependency_tracking" = xyes; then continue else break fi ;; msvc7 | msvc7msys | msvisualcpp | msvcmsys) # This compiler won't grok '-c -o', but also, the minuso test has # not run yet. These depmodes are late enough in the game, and # so weak that their functioning should not be impacted. am__obj=conftest.${OBJEXT-o} am__minus_obj= ;; none) break ;; esac if depmode=$depmode \ source=sub/conftest.c object=$am__obj \ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ >/dev/null 2>conftest.err && grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && grep $am__obj sub/conftest.Po > /dev/null 2>&1 && ${MAKE-make} -s -f confmf > /dev/null 2>&1; then # icc doesn't choke on unknown options, it will just issue warnings # or remarks (even with -Werror). So we grep stderr for any message # that says an option was ignored or not supported. # When given -MP, icc 7.0 and 7.1 complain thusly: # icc: Command line warning: ignoring option '-M'; no argument required # The diagnosis changed in icc 8.0: # icc: Command line remark: option '-MP' not supported if (grep 'ignoring option' conftest.err || grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else am_cv_CC_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_CC_dependencies_compiler_type=none fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; } CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type if test "x$enable_dependency_tracking" != xno \ && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then am__fastdepCC_TRUE= am__fastdepCC_FALSE='#' else am__fastdepCC_TRUE='#' am__fastdepCC_FALSE= fi is_darwin=no case "${host_os}" in darwin*) is_darwin=yes ;; esac if test "$is_darwin" = "yes"; then DARWIN_TRUE= DARWIN_FALSE='#' else DARWIN_TRUE='#' DARWIN_FALSE= fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 printf %s "checking how to run the C preprocessor... " >&6; } # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then if test ${ac_cv_prog_CPP+y} then : printf %s "(cached) " >&6 else $as_nop # Double quotes because $CC needs to be expanded for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp do ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO" then : else $as_nop # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO" then : # Broken: success on invalid input. continue else $as_nop # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok then : break fi done ac_cv_prog_CPP=$CPP fi CPP=$ac_cv_prog_CPP else ac_cv_prog_CPP=$CPP fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 printf "%s\n" "$CPP" >&6; } ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO" then : else $as_nop # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO" then : # Broken: success on invalid input. continue else $as_nop # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok then : else $as_nop { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check See \`config.log' for more details" "$LINENO" 5; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 printf %s "checking for grep that handles long lines and -e... " >&6; } if test ${ac_cv_path_GREP+y} then : printf %s "(cached) " >&6 else $as_nop if test -z "$GREP"; then ac_path_GREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_prog in grep ggrep do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_GREP="$as_dir$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_GREP" || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case `"$ac_path_GREP" --version 2>&1` in *GNU*) ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; *) ac_count=0 printf %s 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" printf "%s\n" 'GREP' >> "conftest.nl" "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_GREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_GREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_GREP"; then as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_GREP=$GREP fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 printf "%s\n" "$ac_cv_path_GREP" >&6; } GREP="$ac_cv_path_GREP" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 printf %s "checking for egrep... " >&6; } if test ${ac_cv_path_EGREP+y} then : printf %s "(cached) " >&6 else $as_nop if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 then ac_cv_path_EGREP="$GREP -E" else if test -z "$EGREP"; then ac_path_EGREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_prog in egrep do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_EGREP" || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case `"$ac_path_EGREP" --version 2>&1` in *GNU*) ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; *) ac_count=0 printf %s 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" printf "%s\n" 'EGREP' >> "conftest.nl" "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_EGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_EGREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_EGREP"; then as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_EGREP=$EGREP fi fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 printf "%s\n" "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" ICC="no" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for icc in use" >&5 printf %s "checking for icc in use... " >&6; } if test "$GCC" = "yes"; then cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ __INTEL_COMPILER _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "^__INTEL_COMPILER" >/dev/null 2>&1 then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } else $as_nop { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } ICC="yes" fi rm -rf conftest* else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for clang in use" >&5 printf %s "checking for clang in use... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { #ifndef __clang__ not clang #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : CLANG=yes else $as_nop CLANG=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CLANG" >&5 printf "%s\n" "$CLANG" >&6; } if test "$CLANG" = "yes" then : fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC options needed to detect all undeclared functions" >&5 printf %s "checking for $CC options needed to detect all undeclared functions... " >&6; } if test ${ac_cv_c_undeclared_builtin_options+y} then : printf %s "(cached) " >&6 else $as_nop ac_save_CFLAGS=$CFLAGS ac_cv_c_undeclared_builtin_options='cannot detect' for ac_arg in '' -fno-builtin; do CFLAGS="$ac_save_CFLAGS $ac_arg" # This test program should *not* compile successfully. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { (void) strchr; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : else $as_nop # This test program should compile successfully. # No library function is consistently available on # freestanding implementations, so test against a dummy # declaration. Include always-available headers on the # off chance that they somehow elicit warnings. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include extern void ac_decl (int, char *); int main (void) { (void) ac_decl (0, (char *) 0); (void) ac_decl; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : if test x"$ac_arg" = x then : ac_cv_c_undeclared_builtin_options='none needed' else $as_nop ac_cv_c_undeclared_builtin_options=$ac_arg fi break fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext done CFLAGS=$ac_save_CFLAGS fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_undeclared_builtin_options" >&5 printf "%s\n" "$ac_cv_c_undeclared_builtin_options" >&6; } case $ac_cv_c_undeclared_builtin_options in #( 'cannot detect') : { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot make $CC report undeclared builtins See \`config.log' for more details" "$LINENO" 5; } ;; #( 'none needed') : ac_c_undeclared_builtin_options='' ;; #( *) : ac_c_undeclared_builtin_options=$ac_cv_c_undeclared_builtin_options ;; esac ac_header= ac_cache= for ac_item in $ac_header_c_list do if test $ac_cache; then ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default" if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then printf "%s\n" "#define $ac_item 1" >> confdefs.h fi ac_header= ac_cache= elif test $ac_header; then ac_cache=$ac_item else ac_header=$ac_item fi done if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes then : printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h fi ac_fn_check_decl "$LINENO" "__SUNPRO_C" "ac_cv_have_decl___SUNPRO_C" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" if test "x$ac_cv_have_decl___SUNPRO_C" = xyes then : SUNCC="yes" else $as_nop SUNCC="no" fi if test "x$SUNCC" = "xyes" then : CFLAGS="-mt $CFLAGS" fi if test "$ICC" = "yes" -o "$GCC" = "yes" then : if test "$CLANG" = "no" then : CFLAGS="$CFLAGS -pthread" fi fi if test "$CLANG" = "yes" then : CFLAGS="$CFLAGS -Wno-language-extension-token" fi if test "$ICC" = "no"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C99" >&5 printf %s "checking for $CC option to accept ISO C99... " >&6; } if test ${ac_cv_prog_cc_c99+y} then : printf %s "(cached) " >&6 else $as_nop ac_cv_prog_cc_c99=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include #include // Check varargs macros. These examples are taken from C99 6.10.3.5. #define debug(...) fprintf (stderr, __VA_ARGS__) #define showlist(...) puts (#__VA_ARGS__) #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) static void test_varargs_macros (void) { int x = 1234; int y = 5678; debug ("Flag"); debug ("X = %d\n", x); showlist (The first, second, and third items.); report (x>y, "x is %d but y is %d", x, y); } // Check long long types. #define BIG64 18446744073709551615ull #define BIG32 4294967295ul #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) #if !BIG_OK your preprocessor is broken; #endif #if BIG_OK #else your preprocessor is broken; #endif static long long int bignum = -9223372036854775807LL; static unsigned long long int ubignum = BIG64; struct incomplete_array { int datasize; double data[]; }; struct named_init { int number; const wchar_t *name; double average; }; typedef const char *ccp; static inline int test_restrict (ccp restrict text) { // See if C++-style comments work. // Iterate through items via the restricted pointer. // Also check for declarations in for loops. for (unsigned int i = 0; *(text+i) != '\0'; ++i) continue; return 0; } // Check varargs and va_copy. static void test_varargs (const char *format, ...) { va_list args; va_start (args, format); va_list args_copy; va_copy (args_copy, args); const char *str; int number; float fnumber; while (*format) { switch (*format++) { case 's': // string str = va_arg (args_copy, const char *); break; case 'd': // int number = va_arg (args_copy, int); break; case 'f': // float fnumber = va_arg (args_copy, double); break; default: break; } } va_end (args_copy); va_end (args); } int main (void) { // Check bool. _Bool success = false; // Check restrict. if (test_restrict ("String literal") == 0) success = true; char *restrict newvar = "Another string"; // Check varargs. test_varargs ("s, d' f .", "string", 65, 34.234); test_varargs_macros (); // Check flexible array members. struct incomplete_array *ia = malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); ia->datasize = 10; for (int i = 0; i < ia->datasize; ++i) ia->data[i] = i * 1.234; // Check named initializers. struct named_init ni = { .number = 34, .name = L"Test wide string", .average = 543.34343, }; ni.number = 58; int dynamic_array[ni.number]; dynamic_array[ni.number - 1] = 543; // work around unused variable warnings return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x' || dynamic_array[ni.number - 1] != 543); ; return 0; } _ACEOF for ac_arg in '' -std=gnu99 -c99 -qlanglvl=extc99 do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_c99=$ac_arg fi rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c99" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c99" in x) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } ;; xno) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c99" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 printf "%s\n" "$ac_cv_prog_cc_c99" >&6; } ;; esac if test "x$ac_cv_prog_cc_c99" != xno then : fi fi # Check whether --enable-extstore was given. if test ${enable_extstore+y} then : enableval=$enable_extstore; fi # Check whether --enable-seccomp was given. if test ${enable_seccomp+y} then : enableval=$enable_seccomp; fi # Check whether --enable-sasl was given. if test ${enable_sasl+y} then : enableval=$enable_sasl; fi # Check whether --enable-sasl_pwdb was given. if test ${enable_sasl_pwdb+y} then : enableval=$enable_sasl_pwdb; fi if test "x$enable_sasl_pwdb" = "xyes" then : enable_sasl=yes fi # Check whether --enable-tls was given. if test ${enable_tls+y} then : enableval=$enable_tls; fi # Check whether --enable-asan was given. if test ${enable_asan+y} then : enableval=$enable_asan; fi # Check whether --enable-static was given. if test ${enable_static+y} then : enableval=$enable_static; fi # Check whether --enable-unix_socket was given. if test ${enable_unix_socket+y} then : enableval=$enable_unix_socket; fi # Check whether --enable-proxy was given. if test ${enable_proxy+y} then : enableval=$enable_proxy; fi # Check whether --enable-proxy-uring was given. if test ${enable_proxy_uring+y} then : enableval=$enable_proxy_uring; fi # Check whether --enable-werror was given. if test ${enable_werror+y} then : enableval=$enable_werror; fi ac_fn_c_check_header_compile "$LINENO" "sasl/sasl.h" "ac_cv_header_sasl_sasl_h" "$ac_includes_default" if test "x$ac_cv_header_sasl_sasl_h" = xyes then : printf "%s\n" "#define HAVE_SASL_SASL_H 1" >>confdefs.h fi if test "x$enable_sasl" = "xyes"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SASL_CB_GETCONF" >&5 printf %s "checking for SASL_CB_GETCONF... " >&6; } if test ${ac_cv_c_sasl_cb_getconf+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main (void) { unsigned long val = SASL_CB_GETCONF; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_c_sasl_cb_getconf=yes else $as_nop ac_cv_c_sasl_cb_getconf=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_sasl_cb_getconf" >&5 printf "%s\n" "$ac_cv_c_sasl_cb_getconf" >&6; } if test "$ac_cv_c_sasl_cb_getconf" = "yes" then : printf "%s\n" "#define HAVE_SASL_CB_GETCONF 1" >>confdefs.h fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SASL_CB_GETCONFPATH" >&5 printf %s "checking for SASL_CB_GETCONFPATH... " >&6; } if test ${ac_cv_c_sasl_cb_getconfpath+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main (void) { unsigned long val = SASL_CB_GETCONFPATH; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_c_sasl_cb_getconfpath=yes else $as_nop ac_cv_c_sasl_cb_getconfpath=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_sasl_cb_getconfpath" >&5 printf "%s\n" "$ac_cv_c_sasl_cb_getconfpath" >&6; } if test "$ac_cv_c_sasl_cb_getconfpath" = "yes" then : printf "%s\n" "#define HAVE_SASL_CB_GETCONFPATH 1" >>confdefs.h fi printf "%s\n" "#define ENABLE_SASL 1" >>confdefs.h { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing sasl_server_init" >&5 printf %s "checking for library containing sasl_server_init... " >&6; } if test ${ac_cv_search_sasl_server_init+y} then : printf %s "(cached) " >&6 else $as_nop ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ char sasl_server_init (); int main (void) { return sasl_server_init (); ; return 0; } _ACEOF for ac_lib in '' sasl2 sasl do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO" then : ac_cv_search_sasl_server_init=$ac_res fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext if test ${ac_cv_search_sasl_server_init+y} then : break fi done if test ${ac_cv_search_sasl_server_init+y} then : else $as_nop ac_cv_search_sasl_server_init=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_sasl_server_init" >&5 printf "%s\n" "$ac_cv_search_sasl_server_init" >&6; } ac_res=$ac_cv_search_sasl_server_init if test "$ac_res" != no then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" else $as_nop as_fn_error $? "Failed to locate the library containing sasl_server_init" "$LINENO" 5 fi if test "x$enable_sasl_pwdb" = "xyes" then : printf "%s\n" "#define ENABLE_SASL_PWDB 1" >>confdefs.h fi fi # Check whether --enable-dtrace was given. if test ${enable_dtrace+y} then : enableval=$enable_dtrace; fi if test "x$enable_dtrace" = "xyes"; then # Extract the first word of "dtrace", so it can be a program name with args. set dummy dtrace; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_DTRACE+y} then : printf %s "(cached) " >&6 else $as_nop case $DTRACE in [\\/]* | ?:[\\/]*) ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_dummy="/usr/sbin:$PATH" for as_dir in $as_dummy do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_DTRACE="$as_dir$ac_word$ac_exec_ext" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS test -z "$ac_cv_path_DTRACE" && ac_cv_path_DTRACE=""no"" ;; esac fi DTRACE=$ac_cv_path_DTRACE if test -n "$DTRACE"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5 printf "%s\n" "$DTRACE" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$DTRACE" != "xno"; then printf "%s\n" "#define ENABLE_DTRACE 1" >>confdefs.h build_dtrace=yes $DTRACE -h -o conftest.h -s memcached_dtrace.d 2>/dev/zero if test $? -eq 0 then dtrace_instrument_obj=yes rm conftest.h # on Mac probe id are generated with $ if test "$is_darwin" = "yes"; then CFLAGS="$CFLAGS -Wno-dollar-in-identifier-extension" fi fi if test "`which tr`" = "/usr/ucb/tr"; then as_fn_error $? "Please remove /usr/ucb from your path. See man standards for more info" "$LINENO" 5 fi else as_fn_error $? "Need dtrace binary and OS support." "$LINENO" 5 fi fi if test "x$enable_extstore" != "xno"; then printf "%s\n" "#define EXTSTORE 1" >>confdefs.h fi if test "x$enable_tls" = "xyes"; then printf "%s\n" "#define TLS 1" >>confdefs.h fi if test "x$enable_asan" = "xyes"; then printf "%s\n" "#define ASAN 1" >>confdefs.h fi if test "x$enable_static" = "xyes"; then printf "%s\n" "#define STATIC 1" >>confdefs.h fi if test "x$enable_unix_socket" = "xno"; then printf "%s\n" "#define DISABLE_UNIX_SOCKET 1" >>confdefs.h fi if test "x$enable_proxy" = "xyes"; then printf "%s\n" "#define PROXY 1" >>confdefs.h CPPFLAGS="-Ivendor/lua/src -Ivendor/liburing/src/include $CPPFLAGS" LIBS="$LIBS -lm -ldl" fi if test "x$enable_proxy_uring" = "xyes"; then printf "%s\n" "#define HAVE_LIBURING 1" >>confdefs.h CPPFLAGS="-Ivendor/liburing/src/include $CPPFLAGS" fi if test "$build_dtrace" = "yes"; then BUILD_DTRACE_TRUE= BUILD_DTRACE_FALSE='#' else BUILD_DTRACE_TRUE='#' BUILD_DTRACE_FALSE= fi if test "$dtrace_instrument_obj" = "yes"; then DTRACE_INSTRUMENT_OBJ_TRUE= DTRACE_INSTRUMENT_OBJ_FALSE='#' else DTRACE_INSTRUMENT_OBJ_TRUE='#' DTRACE_INSTRUMENT_OBJ_FALSE= fi if test "$enable_sasl" = "yes"; then ENABLE_SASL_TRUE= ENABLE_SASL_FALSE='#' else ENABLE_SASL_TRUE='#' ENABLE_SASL_FALSE= fi if test "$enable_extstore" != "no"; then ENABLE_EXTSTORE_TRUE= ENABLE_EXTSTORE_FALSE='#' else ENABLE_EXTSTORE_TRUE='#' ENABLE_EXTSTORE_FALSE= fi if test "$enable_arm_crc32" = "yes"; then ENABLE_ARM_CRC32_TRUE= ENABLE_ARM_CRC32_FALSE='#' else ENABLE_ARM_CRC32_TRUE='#' ENABLE_ARM_CRC32_FALSE= fi if test "$enable_tls" = "yes"; then ENABLE_TLS_TRUE= ENABLE_TLS_FALSE='#' else ENABLE_TLS_TRUE='#' ENABLE_TLS_FALSE= fi if test "$enable_asan" = "yes"; then ENABLE_ASAN_TRUE= ENABLE_ASAN_FALSE='#' else ENABLE_ASAN_TRUE='#' ENABLE_ASAN_FALSE= fi if test "$enable_static" = "yes"; then ENABLE_STATIC_TRUE= ENABLE_STATIC_FALSE='#' else ENABLE_STATIC_TRUE='#' ENABLE_STATIC_FALSE= fi if test "$enable_unix_socket" = "no"; then DISABLE_UNIX_SOCKET_TRUE= DISABLE_UNIX_SOCKET_FALSE='#' else DISABLE_UNIX_SOCKET_TRUE='#' DISABLE_UNIX_SOCKET_FALSE= fi if test "$enable_proxy" = "yes"; then ENABLE_PROXY_TRUE= ENABLE_PROXY_FALSE='#' else ENABLE_PROXY_TRUE='#' ENABLE_PROXY_FALSE= fi if test "$enable_proxy_uring" = "yes"; then ENABLE_PROXY_URING_TRUE= ENABLE_PROXY_URING_FALSE='#' else ENABLE_PROXY_URING_TRUE='#' ENABLE_PROXY_URING_FALSE= fi # Check whether --enable-coverage was given. if test ${enable_coverage+y} then : enableval=$enable_coverage; fi if test "x$enable_coverage" != "xno"; then if test "$GCC" = "yes" -a "$ICC" != "yes" -a "$CLANG" != "yes" then CFLAGS="$CFLAGS -pthread" # Extract the first word of "gcov", so it can be a program name with args. set dummy gcov; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_PROFILER+y} then : printf %s "(cached) " >&6 else $as_nop case $PROFILER in [\\/]* | ?:[\\/]*) ac_cv_path_PROFILER="$PROFILER" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_PROFILER="$as_dir$ac_word$ac_exec_ext" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS test -z "$ac_cv_path_PROFILER" && ac_cv_path_PROFILER=""no"" ;; esac fi PROFILER=$ac_cv_path_PROFILER if test -n "$PROFILER"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PROFILER" >&5 printf "%s\n" "$PROFILER" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$PROFILER" != "xno"; then # Issue 97: The existence of gcov doesn't mean we have -lgcov { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for main in -lgcov" >&5 printf %s "checking for main in -lgcov... " >&6; } if test ${ac_cv_lib_gcov_main+y} then : printf %s "(cached) " >&6 else $as_nop ac_check_lib_save_LIBS=$LIBS LIBS="-lgcov $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { return main (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_gcov_main=yes else $as_nop ac_cv_lib_gcov_main=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gcov_main" >&5 printf "%s\n" "$ac_cv_lib_gcov_main" >&6; } if test "x$ac_cv_lib_gcov_main" = xyes then : PROFILER_FLAGS="-fprofile-arcs -ftest-coverage" PROFILER_LDFLAGS="-lgcov" else $as_nop PROFILER_FLAGS= PROFILER_LDFLAGS= fi fi elif test "$SUNCC" = "yes" then # Extract the first word of "tcov", so it can be a program name with args. set dummy tcov; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_PROFILER+y} then : printf %s "(cached) " >&6 else $as_nop case $PROFILER in [\\/]* | ?:[\\/]*) ac_cv_path_PROFILER="$PROFILER" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_PROFILER="$as_dir$ac_word$ac_exec_ext" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS test -z "$ac_cv_path_PROFILER" && ac_cv_path_PROFILER=""no"" ;; esac fi PROFILER=$ac_cv_path_PROFILER if test -n "$PROFILER"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PROFILER" >&5 printf "%s\n" "$PROFILER" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$PROFILER" != "xno"; then PROFILER_FLAGS=-xprofile=tcov fi elif test "x$CLANG" != "xno" then # Extract the first word of "gcov", so it can be a program name with args. set dummy gcov; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_PROFILER+y} then : printf %s "(cached) " >&6 else $as_nop case $PROFILER in [\\/]* | ?:[\\/]*) ac_cv_path_PROFILER="$PROFILER" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_PROFILER="$as_dir$ac_word$ac_exec_ext" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS test -z "$ac_cv_path_PROFILER" && ac_cv_path_PROFILER=""no"" ;; esac fi PROFILER=$ac_cv_path_PROFILER if test -n "$PROFILER"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PROFILER" >&5 printf "%s\n" "$PROFILER" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$PROFILER" != "xno" then PROFILER_FLAGS="-fprofile-arcs -ftest-coverage" PROFILER_LDFLAGS= fi fi fi # Check whether --enable-64bit was given. if test ${enable_64bit+y} then : enableval=$enable_64bit; fi if test "x$enable_64bit" = "xyes" then org_cflags=$CFLAGS CFLAGS=-m64 if test "$cross_compiling" = yes then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Assuming no extra CFLAGS are required for cross-compiling 64bit version." >&5 printf "%s\n" "$as_me: WARNING: Assuming no extra CFLAGS are required for cross-compiling 64bit version." >&2;} else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { return sizeof(void*) == 8 ? 0 : 1; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO" then : CFLAGS="-m64 $org_cflags" else $as_nop as_fn_error $? "Don't know how to build a 64-bit object." "$LINENO" 5 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of void *" >&5 printf %s "checking size of void *... " >&6; } if test ${ac_cv_sizeof_void_p+y} then : printf %s "(cached) " >&6 else $as_nop if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (void *))" "ac_cv_sizeof_void_p" "$ac_includes_default" then : else $as_nop if test "$ac_cv_type_void_p" = yes; then { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "cannot compute sizeof (void *) See \`config.log' for more details" "$LINENO" 5; } else ac_cv_sizeof_void_p=0 fi fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_void_p" >&5 printf "%s\n" "$ac_cv_sizeof_void_p" >&6; } printf "%s\n" "#define SIZEOF_VOID_P $ac_cv_sizeof_void_p" >>confdefs.h # Issue 213: Search for clock_gettime to help people linking # with a static version of libevent { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime" >&5 printf %s "checking for library containing clock_gettime... " >&6; } if test ${ac_cv_search_clock_gettime+y} then : printf %s "(cached) " >&6 else $as_nop ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ char clock_gettime (); int main (void) { return clock_gettime (); ; return 0; } _ACEOF for ac_lib in '' rt do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO" then : ac_cv_search_clock_gettime=$ac_res fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext if test ${ac_cv_search_clock_gettime+y} then : break fi done if test ${ac_cv_search_clock_gettime+y} then : else $as_nop ac_cv_search_clock_gettime=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_clock_gettime" >&5 printf "%s\n" "$ac_cv_search_clock_gettime" >&6; } ac_res=$ac_cv_search_clock_gettime if test "$ac_res" != no then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi # Issue 214: Search for the network libraries _before_ searching # for libevent (to help people linking with static libevent) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5 printf %s "checking for library containing socket... " >&6; } if test ${ac_cv_search_socket+y} then : printf %s "(cached) " >&6 else $as_nop ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ char socket (); int main (void) { return socket (); ; return 0; } _ACEOF for ac_lib in '' socket do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO" then : ac_cv_search_socket=$ac_res fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext if test ${ac_cv_search_socket+y} then : break fi done if test ${ac_cv_search_socket+y} then : else $as_nop ac_cv_search_socket=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5 printf "%s\n" "$ac_cv_search_socket" >&6; } ac_res=$ac_cv_search_socket if test "$ac_res" != no then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing gethostbyname" >&5 printf %s "checking for library containing gethostbyname... " >&6; } if test ${ac_cv_search_gethostbyname+y} then : printf %s "(cached) " >&6 else $as_nop ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ char gethostbyname (); int main (void) { return gethostbyname (); ; return 0; } _ACEOF for ac_lib in '' nsl do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO" then : ac_cv_search_gethostbyname=$ac_res fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext if test ${ac_cv_search_gethostbyname+y} then : break fi done if test ${ac_cv_search_gethostbyname+y} then : else $as_nop ac_cv_search_gethostbyname=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_gethostbyname" >&5 printf "%s\n" "$ac_cv_search_gethostbyname" >&6; } ac_res=$ac_cv_search_gethostbyname if test "$ac_res" != no then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi trylibeventdir="" # Check whether --with-libevent was given. if test ${with_libevent+y} then : withval=$with_libevent; if test "x$withval" != "xno" ; then trylibeventdir=$withval fi fi LIBEVENT_URL=https://www.monkey.org/~provos/libevent/ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libevent directory" >&5 printf %s "checking for libevent directory... " >&6; } if test ${ac_cv_libevent_dir+y} then : printf %s "(cached) " >&6 else $as_nop saved_LIBS="$LIBS" saved_LDFLAGS="$LDFLAGS" saved_CPPFLAGS="$CPPFLAGS" le_found=no for ledir in $trylibeventdir "" $prefix /usr/local ; do LDFLAGS="$saved_LDFLAGS" LIBS="-levent $saved_LIBS" # Skip the directory if it isn't there. if test ! -z "$ledir" -a ! -d "$ledir" ; then continue; fi if test ! -z "$ledir" ; then if test -d "$ledir/lib" ; then LDFLAGS="-L$ledir/lib $LDFLAGS" else LDFLAGS="-L$ledir $LDFLAGS" fi if test -d "$ledir/include" ; then CPPFLAGS="-I$ledir/include $CPPFLAGS" else CPPFLAGS="-I$ledir $CPPFLAGS" fi fi # Can I compile and link it? cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include int main (void) { event_init(); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO" then : libevent_linked=yes else $as_nop libevent_linked=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext if test $libevent_linked = yes; then if test ! -z "$ledir" ; then ac_cv_libevent_dir=$ledir _myos=`echo $target_os | cut -f 1 -d .` if test "$SUNCC" = "yes" -o "x$_myos" = "xsolaris2" then : saved_LDFLAGS="$saved_LDFLAGS -Wl,-R$ledir/lib" else $as_nop if test "$GCC" = "yes" then : saved_LDFLAGS="$saved_LDFLAGS -Wl,-rpath,$ledir/lib" fi fi else ac_cv_libevent_dir="(system)" fi le_found=yes break fi done LIBS="$saved_LIBS" LDFLAGS="$saved_LDFLAGS" CPPFLAGS="$saved_CPPFLAGS" if test $le_found = no ; then as_fn_error $? "libevent is required. You can get it from $LIBEVENT_URL If it's already installed, specify its path using --with-libevent=/dir/ " "$LINENO" 5 fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libevent_dir" >&5 printf "%s\n" "$ac_cv_libevent_dir" >&6; } LIBS="-levent $LIBS" if test $ac_cv_libevent_dir != "(system)"; then if test -d "$ac_cv_libevent_dir/lib" ; then LDFLAGS="-L$ac_cv_libevent_dir/lib $LDFLAGS" le_libdir="$ac_cv_libevent_dir/lib" else LDFLAGS="-L$ac_cv_libevent_dir $LDFLAGS" le_libdir="$ac_cv_libevent_dir" fi if test -d "$ac_cv_libevent_dir/include" ; then CPPFLAGS="-I$ac_cv_libevent_dir/include $CPPFLAGS" else CPPFLAGS="-I$ac_cv_libevent_dir $CPPFLAGS" fi fi if test "$cross_compiling" = yes then : else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main (void) { const char *ver = event_get_version(); return (ver != NULL && *ver != '1') ? 0 : 1; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO" then : printf "%s\n" "#define HAVE_LIBEVENT_NEW 1" >>confdefs.h else $as_nop as_fn_error $? "libevent2 is required" "$LINENO" 5 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi trylibssldir="" # Check whether --with-libssl was given. if test ${with_libssl+y} then : withval=$with_libssl; if test "x$withval" != "xno" ; then trylibssldir=$withval fi fi if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args. set dummy ${ac_tool_prefix}pkg-config; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_PKG_CONFIG+y} then : printf %s "(cached) " >&6 else $as_nop case $PKG_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_PKG_CONFIG="$as_dir$ac_word$ac_exec_ext" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS ;; esac fi PKG_CONFIG=$ac_cv_path_PKG_CONFIG if test -n "$PKG_CONFIG"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5 printf "%s\n" "$PKG_CONFIG" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_path_PKG_CONFIG"; then ac_pt_PKG_CONFIG=$PKG_CONFIG # Extract the first word of "pkg-config", so it can be a program name with args. set dummy pkg-config; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_ac_pt_PKG_CONFIG+y} then : printf %s "(cached) " >&6 else $as_nop case $ac_pt_PKG_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_ac_pt_PKG_CONFIG="$as_dir$ac_word$ac_exec_ext" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS ;; esac fi ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG if test -n "$ac_pt_PKG_CONFIG"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5 printf "%s\n" "$ac_pt_PKG_CONFIG" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_pt_PKG_CONFIG" = x; then PKG_CONFIG="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac PKG_CONFIG=$ac_pt_PKG_CONFIG fi else PKG_CONFIG="$ac_cv_path_PKG_CONFIG" fi fi if test -n "$PKG_CONFIG"; then _pkg_min_version=0.9.0 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5 printf %s "checking pkg-config is at least version $_pkg_min_version... " >&6; } if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } PKG_CONFIG="" fi fi OPENSSL_URL=https://www.openssl.org/ if test "x$enable_tls" = "xyes"; then pkg_failed=no { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for openssl" >&5 printf %s "checking for openssl... " >&6; } if test -n "$OPENSSL_CFLAGS"; then pkg_cv_OPENSSL_CFLAGS="$OPENSSL_CFLAGS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"openssl\""; } >&5 ($PKG_CONFIG --exists --print-errors "openssl") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then pkg_cv_OPENSSL_CFLAGS=`$PKG_CONFIG --cflags "openssl" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes fi else pkg_failed=untried fi if test -n "$OPENSSL_LIBS"; then pkg_cv_OPENSSL_LIBS="$OPENSSL_LIBS" elif test -n "$PKG_CONFIG"; then if test -n "$PKG_CONFIG" && \ { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"openssl\""; } >&5 ($PKG_CONFIG --exists --print-errors "openssl") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then pkg_cv_OPENSSL_LIBS=`$PKG_CONFIG --libs "openssl" 2>/dev/null` test "x$?" != "x0" && pkg_failed=yes else pkg_failed=yes fi else pkg_failed=untried fi if test $pkg_failed = yes; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then _pkg_short_errors_supported=yes else _pkg_short_errors_supported=no fi if test $_pkg_short_errors_supported = yes; then OPENSSL_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "openssl" 2>&1` else OPENSSL_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "openssl" 2>&1` fi # Put the nasty error message in config.log where it belongs echo "$OPENSSL_PKG_ERRORS" >&5 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libssl directory" >&5 printf %s "checking for libssl directory... " >&6; } if test ${ac_cv_libssl_dir+y} then : printf %s "(cached) " >&6 else $as_nop saved_LIBS="$LIBS" saved_LDFLAGS="$LDFLAGS" saved_CPPFLAGS="$CPPFLAGS" le_found=no for ledir in $trylibssldir "" $prefix /usr/local ; do LDFLAGS="$saved_LDFLAGS" LIBS="-lssl -lcrypto $saved_LIBS" # Skip the directory if it isn't there. if test ! -z "$ledir" -a ! -d "$ledir" ; then continue; fi if test ! -z "$ledir" ; then if test -d "$ledir/lib" ; then LDFLAGS="-L$ledir/lib $LDFLAGS" else LDFLAGS="-L$ledir $LDFLAGS" fi if test -d "$ledir/include" ; then CPPFLAGS="-I$ledir/include $CPPFLAGS" else CPPFLAGS="-I$ledir $CPPFLAGS" fi fi # Can I compile and link it? cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main (void) { SSL_CTX* ssl_ctx = SSL_CTX_new(TLS_server_method()); assert(OPENSSL_VERSION_NUMBER >= 0x10100000L); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO" then : libssl_linked=yes else $as_nop libssl_linked=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext if test $libssl_linked = yes; then if test ! -z "$ledir" ; then ac_cv_libssl_dir=$ledir _myos=`echo $target_os | cut -f 1 -d .` if test "$SUNCC" = "yes" -o "x$_myos" = "xsolaris2" then : saved_LDFLAGS="$saved_LDFLAGS -Wl,-R$ledir/lib" else $as_nop if test "$GCC" = "yes" then : saved_LDFLAGS="$saved_LDFLAGS -Wl,-rpath,$ledir/lib" fi fi else ac_cv_libssl_dir="(system)" fi le_found=yes break fi done LIBS="$saved_LIBS" LDFLAGS="$saved_LDFLAGS" CPPFLAGS="$saved_CPPFLAGS" if test $le_found = no ; then as_fn_error $? "libssl (at least version 1.1.0) is required. You can get it from $OPENSSL_URL If it's already installed, specify its path using --with-libssl=/dir/ " "$LINENO" 5 fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libssl_dir" >&5 printf "%s\n" "$ac_cv_libssl_dir" >&6; } LIBS="-lssl -lcrypto $LIBS" if test $ac_cv_libssl_dir != "(system)"; then if test -d "$ac_cv_libssl_dir/lib" ; then LDFLAGS="-L$ac_cv_libssl_dir/lib $LDFLAGS" le_libdir="$ac_cv_libssl_dir/lib" else LDFLAGS="-L$ac_cv_libssl_dir $LDFLAGS" le_libdir="$ac_cv_libssl_dir" fi if test -d "$ac_cv_libssl_dir/include" ; then CPPFLAGS="-I$ac_cv_libssl_dir/include $CPPFLAGS" else CPPFLAGS="-I$ac_cv_libssl_dir $CPPFLAGS" fi fi elif test $pkg_failed = untried; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libssl directory" >&5 printf %s "checking for libssl directory... " >&6; } if test ${ac_cv_libssl_dir+y} then : printf %s "(cached) " >&6 else $as_nop saved_LIBS="$LIBS" saved_LDFLAGS="$LDFLAGS" saved_CPPFLAGS="$CPPFLAGS" le_found=no for ledir in $trylibssldir "" $prefix /usr/local ; do LDFLAGS="$saved_LDFLAGS" LIBS="-lssl -lcrypto $saved_LIBS" # Skip the directory if it isn't there. if test ! -z "$ledir" -a ! -d "$ledir" ; then continue; fi if test ! -z "$ledir" ; then if test -d "$ledir/lib" ; then LDFLAGS="-L$ledir/lib $LDFLAGS" else LDFLAGS="-L$ledir $LDFLAGS" fi if test -d "$ledir/include" ; then CPPFLAGS="-I$ledir/include $CPPFLAGS" else CPPFLAGS="-I$ledir $CPPFLAGS" fi fi # Can I compile and link it? cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main (void) { SSL_CTX* ssl_ctx = SSL_CTX_new(TLS_server_method()); assert(OPENSSL_VERSION_NUMBER >= 0x10100000L); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO" then : libssl_linked=yes else $as_nop libssl_linked=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext if test $libssl_linked = yes; then if test ! -z "$ledir" ; then ac_cv_libssl_dir=$ledir _myos=`echo $target_os | cut -f 1 -d .` if test "$SUNCC" = "yes" -o "x$_myos" = "xsolaris2" then : saved_LDFLAGS="$saved_LDFLAGS -Wl,-R$ledir/lib" else $as_nop if test "$GCC" = "yes" then : saved_LDFLAGS="$saved_LDFLAGS -Wl,-rpath,$ledir/lib" fi fi else ac_cv_libssl_dir="(system)" fi le_found=yes break fi done LIBS="$saved_LIBS" LDFLAGS="$saved_LDFLAGS" CPPFLAGS="$saved_CPPFLAGS" if test $le_found = no ; then as_fn_error $? "libssl (at least version 1.1.0) is required. You can get it from $OPENSSL_URL If it's already installed, specify its path using --with-libssl=/dir/ " "$LINENO" 5 fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libssl_dir" >&5 printf "%s\n" "$ac_cv_libssl_dir" >&6; } LIBS="-lssl -lcrypto $LIBS" if test $ac_cv_libssl_dir != "(system)"; then if test -d "$ac_cv_libssl_dir/lib" ; then LDFLAGS="-L$ac_cv_libssl_dir/lib $LDFLAGS" le_libdir="$ac_cv_libssl_dir/lib" else LDFLAGS="-L$ac_cv_libssl_dir $LDFLAGS" le_libdir="$ac_cv_libssl_dir" fi if test -d "$ac_cv_libssl_dir/include" ; then CPPFLAGS="-I$ac_cv_libssl_dir/include $CPPFLAGS" else CPPFLAGS="-I$ac_cv_libssl_dir $CPPFLAGS" fi fi else OPENSSL_CFLAGS=$pkg_cv_OPENSSL_CFLAGS OPENSSL_LIBS=$pkg_cv_OPENSSL_LIBS { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } LIBS="$LIBS $OPENSSL_LIBS" CFLAGS="$CFLAGS $OPENSSL_CFLAGS" fi fi if test "x$enable_static" = "xyes"; then LIBS="$LIBS -ldl" LDFLAGS="-static $LDFLAGS" fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing gethugepagesizes" >&5 printf %s "checking for library containing gethugepagesizes... " >&6; } if test ${ac_cv_search_gethugepagesizes+y} then : printf %s "(cached) " >&6 else $as_nop ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ char gethugepagesizes (); int main (void) { return gethugepagesizes (); ; return 0; } _ACEOF for ac_lib in '' hugetlbfs do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO" then : ac_cv_search_gethugepagesizes=$ac_res fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext if test ${ac_cv_search_gethugepagesizes+y} then : break fi done if test ${ac_cv_search_gethugepagesizes+y} then : else $as_nop ac_cv_search_gethugepagesizes=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_gethugepagesizes" >&5 printf "%s\n" "$ac_cv_search_gethugepagesizes" >&6; } ac_res=$ac_cv_search_gethugepagesizes if test "$ac_res" != no then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default" if test "x$ac_cv_type__Bool" = xyes then : printf "%s\n" "#define HAVE__BOOL 1" >>confdefs.h fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99" >&5 printf %s "checking for stdbool.h that conforms to C99... " >&6; } if test ${ac_cv_header_stdbool_h+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #ifndef __bool_true_false_are_defined #error "__bool_true_false_are_defined is not defined" #endif char a[__bool_true_false_are_defined == 1 ? 1 : -1]; /* Regardless of whether this is C++ or "_Bool" is a valid type name, "true" and "false" should be usable in #if expressions and integer constant expressions, and "bool" should be a valid type name. */ #if !true #error "'true' is not true" #endif #if true != 1 #error "'true' is not equal to 1" #endif char b[true == 1 ? 1 : -1]; char c[true]; #if false #error "'false' is not false" #endif #if false != 0 #error "'false' is not equal to 0" #endif char d[false == 0 ? 1 : -1]; enum { e = false, f = true, g = false * true, h = true * 256 }; char i[(bool) 0.5 == true ? 1 : -1]; char j[(bool) 0.0 == false ? 1 : -1]; char k[sizeof (bool) > 0 ? 1 : -1]; struct sb { bool s: 1; bool t; } s; char l[sizeof s.t > 0 ? 1 : -1]; /* The following fails for HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */ bool m[h]; char n[sizeof m == h * sizeof m[0] ? 1 : -1]; char o[-1 - (bool) 0 < 0 ? 1 : -1]; /* Catch a bug in an HP-UX C compiler. See https://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html https://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html */ bool p = true; bool *pp = &p; /* C 1999 specifies that bool, true, and false are to be macros, but C++ 2011 and later overrule this. */ #if __cplusplus < 201103 #ifndef bool #error "bool is not defined" #endif #ifndef false #error "false is not defined" #endif #ifndef true #error "true is not defined" #endif #endif /* If _Bool is available, repeat with it all the tests above that used bool. */ #ifdef HAVE__BOOL struct sB { _Bool s: 1; _Bool t; } t; char q[(_Bool) 0.5 == true ? 1 : -1]; char r[(_Bool) 0.0 == false ? 1 : -1]; char u[sizeof (_Bool) > 0 ? 1 : -1]; char v[sizeof t.t > 0 ? 1 : -1]; _Bool w[h]; char x[sizeof m == h * sizeof m[0] ? 1 : -1]; char y[-1 - (_Bool) 0 < 0 ? 1 : -1]; _Bool z = true; _Bool *pz = &p; #endif int main (void) { bool ps = &s; *pp |= p; *pp |= ! p; #ifdef HAVE__BOOL _Bool pt = &t; *pz |= z; *pz |= ! z; #endif /* Refer to every declared value, so they cannot be discarded as unused. */ return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !j + !k + !l + !m + !n + !o + !p + !pp + !ps #ifdef HAVE__BOOL + !q + !r + !u + !v + !w + !x + !y + !z + !pt #endif ); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_header_stdbool_h=yes else $as_nop ac_cv_header_stdbool_h=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5 printf "%s\n" "$ac_cv_header_stdbool_h" >&6; } if test $ac_cv_header_stdbool_h = yes; then printf "%s\n" "#define HAVE_STDBOOL_H 1" >>confdefs.h fi ac_fn_c_check_header_compile "$LINENO" "inttypes.h" "ac_cv_header_inttypes_h" "$ac_includes_default" if test "x$ac_cv_header_inttypes_h" = xyes then : printf "%s\n" "#define HAVE_INTTYPES_H 1" >>confdefs.h fi ac_fn_c_check_header_compile "$LINENO" "sys/auxv.h" "ac_cv_header_sys_auxv_h" "$ac_includes_default" if test "x$ac_cv_header_sys_auxv_h" = xyes then : printf "%s\n" "#define HAVE_SYS_AUXV_H 1" >>confdefs.h fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sasl_callback_ft" >&5 printf %s "checking for sasl_callback_ft... " >&6; } if test ${ac_cv_has_sasl_callback_ft+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef HAVE_SASL_SASL_H #include #include #endif int main (void) { sasl_callback_ft a_callback; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_has_sasl_callback_ft=yes else $as_nop ac_cv_has_sasl_callback_ft=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_has_sasl_callback_ft" >&5 printf "%s\n" "$ac_cv_has_sasl_callback_ft" >&6; } if test $ac_cv_has_sasl_callback_ft = yes; then printf "%s\n" "#define HAVE_SASL_CALLBACK_FT 1" >>confdefs.h fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for print macros for integers (C99 section 7.8.1)" >&5 printf %s "checking for print macros for integers (C99 section 7.8.1)... " >&6; } if test ${ac_cv_c_uint64_support+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef HAVE_INTTYPES_H #include #endif #include int main (void) { uint64_t val = 0; fprintf(stderr, "%" PRIu64 "\n", val); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_c_uint64_support=yes else $as_nop ac_cv_c_uint64_support=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_uint64_support" >&5 printf "%s\n" "$ac_cv_c_uint64_support" >&6; } if test "x$ac_cv_c_uint64_support" = "xno" then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Failed to use print macros (PRIu) as defined in C99 section 7.8.1. " >&5 printf "%s\n" "$as_me: WARNING: Failed to use print macros (PRIu) as defined in C99 section 7.8.1. " >&2;} fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5 printf %s "checking for an ANSI C-conforming const... " >&6; } if test ${ac_cv_c_const+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { #ifndef __cplusplus /* Ultrix mips cc rejects this sort of thing. */ typedef int charset[2]; const charset cs = { 0, 0 }; /* SunOS 4.1.1 cc rejects this. */ char const *const *pcpcc; char **ppc; /* NEC SVR4.0.2 mips cc rejects this. */ struct point {int x, y;}; static struct point const zero = {0,0}; /* IBM XL C 1.02.0.0 rejects this. It does not let you subtract one const X* pointer from another in an arm of an if-expression whose if-part is not a constant expression */ const char *g = "string"; pcpcc = &g + (g ? g-g : 0); /* HPUX 7.0 cc rejects these. */ ++pcpcc; ppc = (char**) pcpcc; pcpcc = (char const *const *) ppc; { /* SCO 3.2v4 cc rejects this sort of thing. */ char tx; char *t = &tx; char const *s = 0 ? (char *) 0 : (char const *) 0; *t++ = 0; if (s) return 0; } { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ int x[] = {25, 17}; const int *foo = &x[0]; ++foo; } { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ typedef const int *iptr; iptr p = 0; ++p; } { /* IBM XL C 1.02.0.0 rejects this sort of thing, saying "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ struct s { int j; const int *ap[3]; } bx; struct s *b = &bx; b->j = 5; } { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ const int foo = 10; if (!foo) return 0; } return !cs[0] && !zero.x; #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_c_const=yes else $as_nop ac_cv_c_const=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5 printf "%s\n" "$ac_cv_c_const" >&6; } if test $ac_cv_c_const = no; then printf "%s\n" "#define const /**/" >>confdefs.h fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for socklen_t" >&5 printf %s "checking for socklen_t... " >&6; } if test ${ac_cv_c_socklen_t+y} then : printf %s "(cached) " >&6 else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main (void) { socklen_t foo; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_c_socklen_t=yes else $as_nop ac_cv_c_socklen_t=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_socklen_t" >&5 printf "%s\n" "$ac_cv_c_socklen_t" >&6; } if test $ac_cv_c_socklen_t = no; then printf "%s\n" "#define socklen_t int" >>confdefs.h fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5 printf %s "checking whether byte ordering is bigendian... " >&6; } if test ${ac_cv_c_bigendian+y} then : printf %s "(cached) " >&6 else $as_nop ac_cv_c_bigendian=unknown # See if we're dealing with a universal compiler. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifndef __APPLE_CC__ not a universal capable compiler #endif typedef int dummy; _ACEOF if ac_fn_c_try_compile "$LINENO" then : # Check for potential -arch flags. It is not universal unless # there are at least two -arch flags with different values. ac_arch= ac_prev= for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do if test -n "$ac_prev"; then case $ac_word in i?86 | x86_64 | ppc | ppc64) if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then ac_arch=$ac_word else ac_cv_c_bigendian=universal break fi ;; esac ac_prev= elif test "x$ac_word" = "x-arch"; then ac_prev=arch fi done fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext if test $ac_cv_c_bigendian = unknown; then # See if sys/param.h defines the BYTE_ORDER macro. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main (void) { #if ! (defined BYTE_ORDER && defined BIG_ENDIAN \ && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \ && LITTLE_ENDIAN) bogus endian macros #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : # It does; now see whether it defined to BIG_ENDIAN or not. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main (void) { #if BYTE_ORDER != BIG_ENDIAN not big endian #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_c_bigendian=yes else $as_nop ac_cv_c_bigendian=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi if test $ac_cv_c_bigendian = unknown; then # See if defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris). cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main (void) { #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN) bogus endian macros #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : # It does; now see whether it defined to _BIG_ENDIAN or not. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main (void) { #ifndef _BIG_ENDIAN not big endian #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_c_bigendian=yes else $as_nop ac_cv_c_bigendian=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi if test $ac_cv_c_bigendian = unknown; then # Compile a test program. if test "$cross_compiling" = yes then : # Try to guess by grepping values from an object file. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ unsigned short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; unsigned short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; int use_ascii (int i) { return ascii_mm[i] + ascii_ii[i]; } unsigned short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; unsigned short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; int use_ebcdic (int i) { return ebcdic_mm[i] + ebcdic_ii[i]; } extern int foo; int main (void) { return use_ascii (foo) == use_ebcdic (foo); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then ac_cv_c_bigendian=yes fi if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then if test "$ac_cv_c_bigendian" = unknown; then ac_cv_c_bigendian=no else # finding both strings is unlikely to happen, but who knows? ac_cv_c_bigendian=unknown fi fi fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main (void) { /* Are we little or big endian? From Harbison&Steele. */ union { long int l; char c[sizeof (long int)]; } u; u.l = 1; return u.c[sizeof (long int) - 1] == 1; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO" then : ac_cv_c_bigendian=no else $as_nop ac_cv_c_bigendian=yes fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5 printf "%s\n" "$ac_cv_c_bigendian" >&6; } case $ac_cv_c_bigendian in #( yes) printf "%s\n" "#define ENDIAN_BIG 1" >>confdefs.h ;; #( no) printf "%s\n" "#define ENDIAN_LITTLE 1" >>confdefs.h ;; #( universal) printf "%s\n" "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h ;; #( *) as_fn_error $? "Cannot detect endianness. Must pass ac_cv_c_bigendian={yes,no} to configure." "$LINENO" 5 ;; esac { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for htonll" >&5 printf %s "checking for htonll... " >&6; } have_htoll="no" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #ifdef HAVE_INTTYPES_H #include */ #endif int main (void) { return htonll(0); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO" then : have_htoll="yes" printf "%s\n" "#define HAVE_HTONLL 1" >>confdefs.h else $as_nop have_htoll="no" fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_htoll" >&5 printf "%s\n" "$have_htoll" >&6; } { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing pthread_create" >&5 printf %s "checking for library containing pthread_create... " >&6; } if test ${ac_cv_search_pthread_create+y} then : printf %s "(cached) " >&6 else $as_nop ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ char pthread_create (); int main (void) { return pthread_create (); ; return 0; } _ACEOF for ac_lib in '' pthread do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO" then : ac_cv_search_pthread_create=$ac_res fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext if test ${ac_cv_search_pthread_create+y} then : break fi done if test ${ac_cv_search_pthread_create+y} then : else $as_nop ac_cv_search_pthread_create=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_pthread_create" >&5 printf "%s\n" "$ac_cv_search_pthread_create" >&6; } ac_res=$ac_cv_search_pthread_create if test "$ac_res" != no then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi if test "x$ac_cv_search_pthread_create" = "xno"; then as_fn_error $? "Can't enable threads without the POSIX thread library." "$LINENO" 5 fi ac_fn_c_check_func "$LINENO" "mlockall" "ac_cv_func_mlockall" if test "x$ac_cv_func_mlockall" = xyes then : printf "%s\n" "#define HAVE_MLOCKALL 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "getpagesizes" "ac_cv_func_getpagesizes" if test "x$ac_cv_func_getpagesizes" = xyes then : printf "%s\n" "#define HAVE_GETPAGESIZES 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "sysconf" "ac_cv_func_sysconf" if test "x$ac_cv_func_sysconf" = xyes then : printf "%s\n" "#define HAVE_SYSCONF 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "memcntl" "ac_cv_func_memcntl" if test "x$ac_cv_func_memcntl" = xyes then : printf "%s\n" "#define HAVE_MEMCNTL 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "clock_gettime" "ac_cv_func_clock_gettime" if test "x$ac_cv_func_clock_gettime" = xyes then : printf "%s\n" "#define HAVE_CLOCK_GETTIME 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "preadv" "ac_cv_func_preadv" if test "x$ac_cv_func_preadv" = xyes then : printf "%s\n" "#define HAVE_PREADV 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "pread" "ac_cv_func_pread" if test "x$ac_cv_func_pread" = xyes then : printf "%s\n" "#define HAVE_PREAD 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "eventfd" "ac_cv_func_eventfd" if test "x$ac_cv_func_eventfd" = xyes then : printf "%s\n" "#define HAVE_EVENTFD 1" >>confdefs.h fi for ac_func in accept4 do : ac_fn_c_check_func "$LINENO" "accept4" "ac_cv_func_accept4" if test "x$ac_cv_func_accept4" = xyes then : printf "%s\n" "#define HAVE_ACCEPT4 1" >>confdefs.h printf "%s\n" "#define HAVE_ACCEPT4 1" >>confdefs.h fi done for ac_func in getopt_long do : ac_fn_c_check_func "$LINENO" "getopt_long" "ac_cv_func_getopt_long" if test "x$ac_cv_func_getopt_long" = xyes then : printf "%s\n" "#define HAVE_GETOPT_LONG 1" >>confdefs.h printf "%s\n" "#define HAVE_GETOPT_LONG 1" >>confdefs.h fi done { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for alignment" >&5 printf %s "checking for alignment... " >&6; } if test ${ac_cv_c_alignment+y} then : printf %s "(cached) " >&6 else $as_nop if test "$cross_compiling" = yes then : ac_cv_c_alignment=maybe else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #pragma GCC optimize ("O0") int main (void) { char *buf = malloc(32); uint64_t *ptr = (uint64_t*)(buf+2); // catch sigbus, etc. *ptr = 0x1; // catch unaligned word access (ARM cpus) #ifdef ENDIAN_BIG #define ALIGNMENT 0x02030405 #else #define ALIGNMENT 0x05040302 #endif *(buf + 0) = 1; *(buf + 1) = 2; *(buf + 2) = 3; *(buf + 3) = 4; *(buf + 4) = 5; int* i = (int*)(buf+1); return (ALIGNMENT == *i) ? 0 : 1; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO" then : ac_cv_c_alignment=none else $as_nop ac_cv_c_alignment=need fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_alignment" >&5 printf "%s\n" "$ac_cv_c_alignment" >&6; } if test $ac_cv_c_alignment = need then : printf "%s\n" "#define NEED_ALIGN 1" >>confdefs.h fi if test $ac_cv_c_alignment = maybe then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Assuming aligned access is required when cross-compiling" >&5 printf "%s\n" "$as_me: WARNING: Assuming aligned access is required when cross-compiling" >&2;} printf "%s\n" "#define NEED_ALIGN 1" >>confdefs.h fi have_gcc_atomics=no { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GCC atomics" >&5 printf %s "checking for GCC atomics... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { unsigned short a; unsigned short b; b = __sync_add_and_fetch(&a, 1); b = __sync_sub_and_fetch(&a, 2); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO" then : have_gcc_atomics=yes printf "%s\n" "#define HAVE_GCC_ATOMICS 1" >>confdefs.h fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_gcc_atomics" >&5 printf "%s\n" "$have_gcc_atomics" >&6; } have_gcc_64atomics=no { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GCC 64bit atomics" >&5 printf %s "checking for GCC 64bit atomics... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main (void) { uint64_t a; uint64_t b; b = __sync_add_and_fetch(&a, 1); b = __sync_sub_and_fetch(&a, 2); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO" then : have_gcc_64atomics=yes printf "%s\n" "#define HAVE_GCC_64ATOMICS 1" >>confdefs.h fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_gcc_64atomics" >&5 printf "%s\n" "$have_gcc_64atomics" >&6; } for ac_func in setppriv do : ac_fn_c_check_func "$LINENO" "setppriv" "ac_cv_func_setppriv" if test "x$ac_cv_func_setppriv" = xyes then : printf "%s\n" "#define HAVE_SETPPRIV 1" >>confdefs.h ac_fn_c_check_header_compile "$LINENO" "priv.h" "ac_cv_header_priv_h" "$ac_includes_default" if test "x$ac_cv_header_priv_h" = xyes then : printf "%s\n" "#define HAVE_DROP_PRIVILEGES 1" >>confdefs.h build_solaris_privs=yes fi fi done if test "x$enable_seccomp" = "xyes" then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for seccomp_rule_add in -lseccomp" >&5 printf %s "checking for seccomp_rule_add in -lseccomp... " >&6; } if test ${ac_cv_lib_seccomp_seccomp_rule_add+y} then : printf %s "(cached) " >&6 else $as_nop ac_check_lib_save_LIBS=$LIBS LIBS="-lseccomp $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ char seccomp_rule_add (); int main (void) { return seccomp_rule_add (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_seccomp_seccomp_rule_add=yes else $as_nop ac_cv_lib_seccomp_seccomp_rule_add=no fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_seccomp_seccomp_rule_add" >&5 printf "%s\n" "$ac_cv_lib_seccomp_seccomp_rule_add" >&6; } if test "x$ac_cv_lib_seccomp_seccomp_rule_add" = xyes then : printf "%s\n" "#define HAVE_DROP_PRIVILEGES 1" >>confdefs.h build_linux_privs=yes printf "%s\n" "#define HAVE_DROP_WORKER_PRIVILEGES 1" >>confdefs.h build_linux_privs=yes fi fi for ac_func in pledge do : ac_fn_c_check_func "$LINENO" "pledge" "ac_cv_func_pledge" if test "x$ac_cv_func_pledge" = xyes then : printf "%s\n" "#define HAVE_PLEDGE 1" >>confdefs.h ac_fn_c_check_header_compile "$LINENO" "unistd.h" "ac_cv_header_unistd_h" "$ac_includes_default" if test "x$ac_cv_header_unistd_h" = xyes then : printf "%s\n" "#define HAVE_DROP_PRIVILEGES 1" >>confdefs.h build_openbsd_privs=yes fi fi done for ac_func in cap_enter do : ac_fn_c_check_func "$LINENO" "cap_enter" "ac_cv_func_cap_enter" if test "x$ac_cv_func_cap_enter" = xyes then : printf "%s\n" "#define HAVE_CAP_ENTER 1" >>confdefs.h ac_fn_c_check_header_compile "$LINENO" "sys/capsicum.h" "ac_cv_header_sys_capsicum_h" "$ac_includes_default" if test "x$ac_cv_header_sys_capsicum_h" = xyes then : printf "%s\n" "#define HAVE_DROP_PRIVILEGES 1" >>confdefs.h build_freebsd_privs=yes fi fi done for ac_func in sandbox_init do : ac_fn_c_check_func "$LINENO" "sandbox_init" "ac_cv_func_sandbox_init" if test "x$ac_cv_func_sandbox_init" = xyes then : printf "%s\n" "#define HAVE_SANDBOX_INIT 1" >>confdefs.h ac_fn_c_check_header_compile "$LINENO" "sandbox.h" "ac_cv_header_sandbox_h" "$ac_includes_default" if test "x$ac_cv_header_sandbox_h" = xyes then : printf "%s\n" "#define HAVE_DROP_PRIVILEGES 1" >>confdefs.h build_darwin_privs=yes fi fi done if test "$build_solaris_privs" = "yes"; then BUILD_SOLARIS_PRIVS_TRUE= BUILD_SOLARIS_PRIVS_FALSE='#' else BUILD_SOLARIS_PRIVS_TRUE='#' BUILD_SOLARIS_PRIVS_FALSE= fi if test "$build_linux_privs" = "yes"; then BUILD_LINUX_PRIVS_TRUE= BUILD_LINUX_PRIVS_FALSE='#' else BUILD_LINUX_PRIVS_TRUE='#' BUILD_LINUX_PRIVS_FALSE= fi if test "$build_openbsd_privs" = "yes"; then BUILD_OPENBSD_PRIVS_TRUE= BUILD_OPENBSD_PRIVS_FALSE='#' else BUILD_OPENBSD_PRIVS_TRUE='#' BUILD_OPENBSD_PRIVS_FALSE= fi if test "$build_freebsd_privs" = "yes"; then BUILD_FREEBSD_PRIVS_TRUE= BUILD_FREEBSD_PRIVS_FALSE='#' else BUILD_FREEBSD_PRIVS_TRUE='#' BUILD_FREEBSD_PRIVS_FALSE= fi if test "$build_darwin_privs" = "yes"; then BUILD_DARWIN_PRIVS_TRUE= BUILD_DARWIN_PRIVS_FALSE='#' else BUILD_DARWIN_PRIVS_TRUE='#' BUILD_DARWIN_PRIVS_FALSE= fi # Check whether --enable-docs was given. if test ${enable_docs+y} then : enableval=$enable_docs; fi # Extract the first word of "xml2rfc", so it can be a program name with args. set dummy xml2rfc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_XML2RFC+y} then : printf %s "(cached) " >&6 else $as_nop case $XML2RFC in [\\/]* | ?:[\\/]*) ac_cv_path_XML2RFC="$XML2RFC" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_XML2RFC="$as_dir$ac_word$ac_exec_ext" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS test -z "$ac_cv_path_XML2RFC" && ac_cv_path_XML2RFC=""no"" ;; esac fi XML2RFC=$ac_cv_path_XML2RFC if test -n "$XML2RFC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XML2RFC" >&5 printf "%s\n" "$XML2RFC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi # Extract the first word of "xsltproc", so it can be a program name with args. set dummy xsltproc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_XSLTPROC+y} then : printf %s "(cached) " >&6 else $as_nop case $XSLTPROC in [\\/]* | ?:[\\/]*) ac_cv_path_XSLTPROC="$XSLTPROC" # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_XSLTPROC="$as_dir$ac_word$ac_exec_ext" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS test -z "$ac_cv_path_XSLTPROC" && ac_cv_path_XSLTPROC=""no"" ;; esac fi XSLTPROC=$ac_cv_path_XSLTPROC if test -n "$XSLTPROC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XSLTPROC" >&5 printf "%s\n" "$XSLTPROC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$enable_docs" != "xno" -a "x$XML2RFC" != "xno" -a "x$XSLTPROC" != "xno"; then BUILD_SPECIFICATIONS_TRUE= BUILD_SPECIFICATIONS_FALSE='#' else BUILD_SPECIFICATIONS_TRUE='#' BUILD_SPECIFICATIONS_FALSE= fi if test "x$enable_werror" = "xyes"; then CFLAGS="$CFLAGS -Werror" fi if test "$ICC" = "yes" then CFLAGS="$CFLAGS -diag-disable 187 -Wall" printf "%s\n" "#define _GNU_SOURCE 1" >>confdefs.h elif test "$GCC" = "yes" then GCC_VERSION=`$CC -dumpversion` CFLAGS="$CFLAGS -Wall -pedantic -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls" if test "x$enable_asan" = "xyes"; then CFLAGS="$CFLAGS -fsanitize=address" fi case $GCC_VERSION in 4.4.*) CFLAGS="$CFLAGS -fno-strict-aliasing" ;; esac printf "%s\n" "#define _GNU_SOURCE 1" >>confdefs.h elif test "$SUNCC" = "yes" then CFLAGS="$CFLAGS -errfmt=error -errwarn -errshort=tags" fi ac_config_files="$ac_config_files Makefile doc/Makefile" cat >confcache <<\_ACEOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # `ac_cv_env_foo' variables (set or unset) will be overridden when # loading this file, other *unset* `ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, we kill variables containing newlines. # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) # `set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) # `set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test ${\1+y} || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 printf "%s\n" "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else case $cache_file in #( */* | ?:*) mv -f confcache "$cache_file"$$ && mv -f "$cache_file"$$ "$cache_file" ;; #( *) mv -f confcache "$cache_file" ;; esac fi fi else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 printf "%s\n" "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' DEFS=-DHAVE_CONFIG_H ac_libobjs= ac_ltlibobjs= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`printf "%s\n" "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5 printf %s "checking that generated files are newer than configure... " >&6; } if test -n "$am_sleep_pid"; then # Hide warnings about reused PIDs. wait $am_sleep_pid 2>/dev/null fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: done" >&5 printf "%s\n" "done" >&6; } if test -n "$EXEEXT"; then am__EXEEXT_TRUE= am__EXEEXT_FALSE='#' else am__EXEEXT_TRUE='#' am__EXEEXT_FALSE= fi if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then as_fn_error $? "conditional \"AMDEP\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then as_fn_error $? "conditional \"am__fastdepCC\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${DARWIN_TRUE}" && test -z "${DARWIN_FALSE}"; then as_fn_error $? "conditional \"DARWIN\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${BUILD_DTRACE_TRUE}" && test -z "${BUILD_DTRACE_FALSE}"; then as_fn_error $? "conditional \"BUILD_DTRACE\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${DTRACE_INSTRUMENT_OBJ_TRUE}" && test -z "${DTRACE_INSTRUMENT_OBJ_FALSE}"; then as_fn_error $? "conditional \"DTRACE_INSTRUMENT_OBJ\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${ENABLE_SASL_TRUE}" && test -z "${ENABLE_SASL_FALSE}"; then as_fn_error $? "conditional \"ENABLE_SASL\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${ENABLE_EXTSTORE_TRUE}" && test -z "${ENABLE_EXTSTORE_FALSE}"; then as_fn_error $? "conditional \"ENABLE_EXTSTORE\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${ENABLE_ARM_CRC32_TRUE}" && test -z "${ENABLE_ARM_CRC32_FALSE}"; then as_fn_error $? "conditional \"ENABLE_ARM_CRC32\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${ENABLE_TLS_TRUE}" && test -z "${ENABLE_TLS_FALSE}"; then as_fn_error $? "conditional \"ENABLE_TLS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${ENABLE_ASAN_TRUE}" && test -z "${ENABLE_ASAN_FALSE}"; then as_fn_error $? "conditional \"ENABLE_ASAN\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${ENABLE_STATIC_TRUE}" && test -z "${ENABLE_STATIC_FALSE}"; then as_fn_error $? "conditional \"ENABLE_STATIC\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${DISABLE_UNIX_SOCKET_TRUE}" && test -z "${DISABLE_UNIX_SOCKET_FALSE}"; then as_fn_error $? "conditional \"DISABLE_UNIX_SOCKET\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${ENABLE_PROXY_TRUE}" && test -z "${ENABLE_PROXY_FALSE}"; then as_fn_error $? "conditional \"ENABLE_PROXY\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${ENABLE_PROXY_URING_TRUE}" && test -z "${ENABLE_PROXY_URING_FALSE}"; then as_fn_error $? "conditional \"ENABLE_PROXY_URING\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${BUILD_SOLARIS_PRIVS_TRUE}" && test -z "${BUILD_SOLARIS_PRIVS_FALSE}"; then as_fn_error $? "conditional \"BUILD_SOLARIS_PRIVS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${BUILD_LINUX_PRIVS_TRUE}" && test -z "${BUILD_LINUX_PRIVS_FALSE}"; then as_fn_error $? "conditional \"BUILD_LINUX_PRIVS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${BUILD_OPENBSD_PRIVS_TRUE}" && test -z "${BUILD_OPENBSD_PRIVS_FALSE}"; then as_fn_error $? "conditional \"BUILD_OPENBSD_PRIVS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${BUILD_FREEBSD_PRIVS_TRUE}" && test -z "${BUILD_FREEBSD_PRIVS_FALSE}"; then as_fn_error $? "conditional \"BUILD_FREEBSD_PRIVS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${BUILD_DARWIN_PRIVS_TRUE}" && test -z "${BUILD_DARWIN_PRIVS_FALSE}"; then as_fn_error $? "conditional \"BUILD_DARWIN_PRIVS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${BUILD_SPECIFICATIONS_TRUE}" && test -z "${BUILD_SPECIFICATIONS_FALSE}"; then as_fn_error $? "conditional \"BUILD_SPECIFICATIONS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 printf "%s\n" "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh as_nop=: if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else $as_nop case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi # Reset variables that may have inherited troublesome values from # the environment. # IFS needs to be set, to space, tab, and newline, in precisely that order. # (If _AS_PATH_WALK were called with IFS unset, it would have the # side effect of setting IFS to empty, thus disabling word splitting.) # Quoting is to prevent editors from complaining about space-tab. as_nl=' ' export as_nl IFS=" "" $as_nl" PS1='$ ' PS2='> ' PS4='+ ' # Ensure predictable behavior from utilities with locale-dependent output. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # We cannot yet rely on "unset" to work, but we need these variables # to be unset--not just set to an empty or harmless value--now, to # avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct # also avoids known problems related to "unset" and subshell syntax # in other old shells (e.g. bash 2.01 and pdksh 5.2.14). for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH do eval test \${$as_var+y} \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done # Ensure that fds 0, 1, and 2 are open. if (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi if (exec 3>&2) ; then :; else exec 2>/dev/null; fi # The user is always right. if ${PATH_SEPARATOR+false} :; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac test -r "$as_dir$0" && as_myself=$as_dir$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi printf "%s\n" "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null then : eval 'as_fn_append () { eval $1+=\$2 }' else $as_nop as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null then : eval 'as_fn_arith () { as_val=$(( $* )) }' else $as_nop as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits # Determine whether it's possible to make 'echo' print without a newline. # These variables are no longer used directly by Autoconf, but are AC_SUBSTed # for compatibility with existing Makefiles. ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac # For backward compatibility with old third-party macros, we provide # the shell variables $as_echo and $as_echo_n. New code should use # AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively. as_echo='printf %s\n' as_echo_n='printf %s' rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by memcached $as_me 1.6.20, which was generated by GNU Autoconf 2.71. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_files in *" "*) set x $ac_config_files; shift; ac_config_files=$*;; esac case $ac_config_headers in *" "*) set x $ac_config_headers; shift; ac_config_headers=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" config_headers="$ac_config_headers" config_commands="$ac_config_commands" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE --header=FILE[:TEMPLATE] instantiate the configuration header FILE Configuration files: $config_files Configuration headers: $config_headers Configuration commands: $config_commands Report bugs to ." _ACEOF ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"` ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"` cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ memcached config.status 1.6.20 configured by $0, generated by GNU Autoconf 2.71, with options \\"\$ac_cs_config\\" Copyright (C) 2021 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' INSTALL='$INSTALL' MKDIR_P='$MKDIR_P' AWK='$AWK' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) printf "%s\n" "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) printf "%s\n" "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append CONFIG_HEADERS " '$ac_optarg'" ac_need_defaults=false;; --he | --h) # Conflict between --help and --header as_fn_error $? "ambiguous option: \`$1' Try \`$0 --help' for more information.";; --help | --hel | -h ) printf "%s\n" "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX printf "%s\n" "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # # INIT-COMMANDS # AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test ${CONFIG_FILES+y} || CONFIG_FILES=$config_files test ${CONFIG_HEADERS+y} || CONFIG_HEADERS=$config_headers test ${CONFIG_COMMANDS+y} || CONFIG_COMMANDS=$config_commands fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF { echo "cat >conf$$subs.awk <<_ACEOF" && echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h s/^/S["/; s/!.*/"]=/ p g s/^[^!]*!// :repl t repl s/'"$ac_delim"'$// t delim :nl h s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p n b repl :more1 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t nl :delim h s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p b :more2 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t delim ' >$CONFIG_STATUS || ac_write_fail=1 rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove sole $(srcdir), # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty # (actually we leave an empty line to preserve line numbers). if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// }' fi cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" # Set up the scripts for CONFIG_HEADERS section. # No need to generate them if there are no CONFIG_HEADERS. # This happens for instance with `./config.status Makefile'. if test -n "$CONFIG_HEADERS"; then cat >"$ac_tmp/defines.awk" <<\_ACAWK || BEGIN { _ACEOF # Transform confdefs.h into an awk script `defines.awk', embedded as # here-document in config.status, that substitutes the proper values into # config.h.in to produce config.h. # Create a delimiter string that does not exist in confdefs.h, to ease # handling of long lines. ac_delim='%!_!# ' for ac_last_try in false false :; do ac_tt=`sed -n "/$ac_delim/p" confdefs.h` if test -z "$ac_tt"; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done # For the awk script, D is an array of macro values keyed by name, # likewise P contains macro parameters if any. Preserve backslash # newline sequences. ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* sed -n ' s/.\{148\}/&'"$ac_delim"'/g t rset :rset s/^[ ]*#[ ]*define[ ][ ]*/ / t def d :def s/\\$// t bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3"/p s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p d :bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3\\\\\\n"\\/p t cont s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p t cont d :cont n s/.\{148\}/&'"$ac_delim"'/g t clear :clear s/\\$// t bsnlc s/["\\]/\\&/g; s/^/"/; s/$/"/p d :bsnlc s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p b cont ' >$CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 for (key in D) D_is_set[key] = 1 FS = "" } /^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { line = \$ 0 split(line, arg, " ") if (arg[1] == "#") { defundef = arg[2] mac1 = arg[3] } else { defundef = substr(arg[1], 2) mac1 = arg[2] } split(mac1, mac2, "(") #) macro = mac2[1] prefix = substr(line, 1, index(line, defundef) - 1) if (D_is_set[macro]) { # Preserve the white space surrounding the "#". print prefix "define", macro P[macro] D[macro] next } else { # Replace #undef with comments. This is necessary, for example, # in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it. if (defundef == "undef") { print "/*", prefix defundef, macro, "*/" next } } } { print } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 fi # test -n "$CONFIG_HEADERS" eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS" shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` printf "%s\n" "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 printf "%s\n" "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`printf "%s\n" "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # case $INSTALL in [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; esac ac_MKDIR_P=$MKDIR_P case $MKDIR_P in [\\/$]* | ?:[\\/]* ) ;; */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;; esac _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 printf "%s\n" "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when `$srcdir' = `.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t s&@INSTALL@&$ac_INSTALL&;t t s&@MKDIR_P@&$ac_MKDIR_P&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; :H) # # CONFIG_HEADER # if test x"$ac_file" != x-; then { printf "%s\n" "/* $configure_input */" >&1 \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" } >"$ac_tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 printf "%s\n" "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" mv "$ac_tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else printf "%s\n" "/* $configure_input */" >&1 \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi # Compute "$ac_file"'s index in $config_headers. _am_arg="$ac_file" _am_stamp_count=1 for _am_header in $config_headers :; do case $_am_header in $_am_arg | $_am_arg:* ) break ;; * ) _am_stamp_count=`expr $_am_stamp_count + 1` ;; esac done echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" || $as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$_am_arg" : 'X\(//\)[^/]' \| \ X"$_am_arg" : 'X\(//\)$' \| \ X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$_am_arg" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'`/stamp-h$_am_stamp_count ;; :C) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 printf "%s\n" "$as_me: executing $ac_file commands" >&6;} ;; esac case $ac_file$ac_mode in "depfiles":C) test x"$AMDEP_TRUE" != x"" || { # Older Autoconf quotes --file arguments for eval, but not when files # are listed without --file. Let's play safe and only enable the eval # if we detect the quoting. # TODO: see whether this extra hack can be removed once we start # requiring Autoconf 2.70 or later. case $CONFIG_FILES in #( *\'*) : eval set x "$CONFIG_FILES" ;; #( *) : set x $CONFIG_FILES ;; #( *) : ;; esac shift # Used to flag and report bootstrapping failures. am_rc=0 for am_mf do # Strip MF so we end up with the name of the file. am_mf=`printf "%s\n" "$am_mf" | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile which includes # dependency-tracking related rules and includes. # Grep'ing the whole file directly is not great: AIX grep has a line # limit of 2048, but all sed's we know have understand at least 4000. sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \ || continue am_dirpart=`$as_dirname -- "$am_mf" || $as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$am_mf" : 'X\(//\)[^/]' \| \ X"$am_mf" : 'X\(//\)$' \| \ X"$am_mf" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$am_mf" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` am_filepart=`$as_basename -- "$am_mf" || $as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \ X"$am_mf" : 'X\(//\)$' \| \ X"$am_mf" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X/"$am_mf" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` { echo "$as_me:$LINENO: cd "$am_dirpart" \ && sed -e '/# am--include-marker/d' "$am_filepart" \ | $MAKE -f - am--depfiles" >&5 (cd "$am_dirpart" \ && sed -e '/# am--include-marker/d' "$am_filepart" \ | $MAKE -f - am--depfiles) >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } || am_rc=$? done if test $am_rc -ne 0; then { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "Something went wrong bootstrapping makefile fragments for automatic dependency tracking. If GNU make was not used, consider re-running the configure script with MAKE=\"gmake\" (or whatever is necessary). You can also try re-running configure with the '--disable-dependency-tracking' option to at least be able to build the package (albeit without support for automatic dependency tracking). See \`config.log' for more details" "$LINENO" 5; } fi { am_dirpart=; unset am_dirpart;} { am_filepart=; unset am_filepart;} { am_mf=; unset am_mf;} { am_rc=; unset am_rc;} rm -f conftest-deps.mk } ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi memcached-1.6.20/murmur3_hash.c0000664000175000017500000000541213704126374013223 00000000000000//----------------------------------------------------------------------------- // MurmurHash3 was written by Austin Appleby, and is placed in the public // domain. The author hereby disclaims copyright to this source code. // Note - The x86 and x64 versions do _not_ produce the same results, as the // algorithms are optimized for their respective platforms. You can still // compile and run any of them on any platform, but your performance with the // non-native version will be less than optimal. #include "murmur3_hash.h" //----------------------------------------------------------------------------- // Platform-specific functions and macros // Microsoft Visual Studio #if defined(_MSC_VER) #define FORCE_INLINE __forceinline #include #define ROTL32(x,y) _rotl(x,y) #define BIG_CONSTANT(x) (x) // Other compilers #else // defined(_MSC_VER) #define FORCE_INLINE inline __attribute__((always_inline)) static inline uint32_t rotl32 ( uint32_t x, int8_t r ) { return (x << r) | (x >> (32 - r)); } #define ROTL32(x,y) rotl32(x,y) #define BIG_CONSTANT(x) (x##LLU) #endif // !defined(_MSC_VER) //----------------------------------------------------------------------------- // Block read - if your platform needs to do endian-swapping or can only // handle aligned reads, do the conversion here static FORCE_INLINE uint32_t getblock32 ( const uint32_t * p, int i ) { return p[i]; } //----------------------------------------------------------------------------- // Finalization mix - force all bits of a hash block to avalanche static FORCE_INLINE uint32_t fmix32 ( uint32_t h ) { h ^= h >> 16; h *= 0x85ebca6b; h ^= h >> 13; h *= 0xc2b2ae35; h ^= h >> 16; return h; } //----------------------------------------------------------------------------- /* Definition modified slightly from the public domain interface (no seed + * return value */ uint32_t MurmurHash3_x86_32 ( const void * key, size_t length) { const uint8_t * data = (const uint8_t*)key; const int nblocks = length / 4; uint32_t h1 = 0; uint32_t c1 = 0xcc9e2d51; uint32_t c2 = 0x1b873593; //---------- // body const uint32_t * blocks = (const uint32_t *)(data + nblocks*4); for(int i = -nblocks; i; i++) { uint32_t k1 = getblock32(blocks,i); k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1; h1 = ROTL32(h1,13); h1 = h1*5+0xe6546b64; } //---------- // tail const uint8_t * tail = (const uint8_t*)(data + nblocks*4); uint32_t k1 = 0; switch(length & 3) { case 3: k1 ^= tail[2] << 16; case 2: k1 ^= tail[1] << 8; case 1: k1 ^= tail[0]; k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1; }; //---------- // finalization h1 ^= length; h1 = fmix32(h1); //*(uint32_t*)out = h1; return h1; } memcached-1.6.20/slabs.h0000664000175000017500000000445214204760331011713 00000000000000/* slabs memory allocation */ #ifndef SLABS_H #define SLABS_H /** Init the subsystem. 1st argument is the limit on no. of bytes to allocate, 0 if no limit. 2nd argument is the growth factor; each slab will use a chunk size equal to the previous slab's chunk size times this factor. 3rd argument specifies if the slab allocator should allocate all memory up front (if true), or allocate memory in chunks as it is needed (if false) */ void slabs_init(const size_t limit, const double factor, const bool prealloc, const uint32_t *slab_sizes, void *mem_base_external, bool reuse_mem); /** Call only during init. Pre-allocates all available memory */ void slabs_prefill_global(void); /** * Given object size, return id to use when allocating/freeing memory for object * 0 means error: can't store such a large object */ unsigned int slabs_clsid(const size_t size); unsigned int slabs_size(const int clsid); /** Allocate object of given length. 0 on error */ /*@null@*/ #define SLABS_ALLOC_NO_NEWPAGE 1 void *slabs_alloc(const size_t size, unsigned int id, unsigned int flags); /** Free previously allocated object */ void slabs_free(void *ptr, size_t size, unsigned int id); /** Adjust global memory limit up or down */ bool slabs_adjust_mem_limit(size_t new_mem_limit); typedef struct { unsigned int chunks_per_page; unsigned int chunk_size; long int free_chunks; long int total_pages; } slab_stats_automove; void fill_slab_stats_automove(slab_stats_automove *am); unsigned int global_page_pool_size(bool *mem_flag); /** Fill buffer with stats */ /*@null@*/ void slabs_stats(ADD_STAT add_stats, void *c); /* Hints as to freespace in slab class */ unsigned int slabs_available_chunks(unsigned int id, bool *mem_flag, unsigned int *chunks_perslab); void slabs_mlock(void); void slabs_munlock(void); int start_slab_maintenance_thread(void); void stop_slab_maintenance_thread(void); enum reassign_result_type { REASSIGN_OK=0, REASSIGN_RUNNING, REASSIGN_BADCLASS, REASSIGN_NOSPARE, REASSIGN_SRC_DST_SAME }; enum reassign_result_type slabs_reassign(int src, int dst); void slabs_rebalancer_pause(void); void slabs_rebalancer_resume(void); #ifdef EXTSTORE void slabs_set_storage(void *arg); #endif /* Fixup for restartable code. */ unsigned int slabs_fixup(char *chunk, const int border); #endif memcached-1.6.20/configure.ac0000664000175000017500000006311214427543277012741 00000000000000AC_PREREQ(2.52) m4_include([version.m4]) m4_include([m4/c99-backport.m4]) AC_INIT([memcached], [VERSION_NUMBER], [memcached@googlegroups.com]) AC_CANONICAL_HOST AC_CONFIG_SRCDIR([memcached.c]) AM_INIT_AUTOMAKE([foreign]) AM_CONFIG_HEADER([config.h]) AC_PROG_CC is_darwin=no case "${host_os}" in darwin*) is_darwin=yes ;; esac AM_CONDITIONAL([DARWIN], [test "$is_darwin" = "yes"]) dnl ********************************************************************** dnl DETECT_ICC ([ACTION-IF-YES], [ACTION-IF-NO]) dnl dnl check if this is the Intel ICC compiler, and if so run the ACTION-IF-YES dnl sets the $ICC variable to "yes" or "no" dnl ********************************************************************** AC_DEFUN([DETECT_ICC], [ ICC="no" AC_MSG_CHECKING([for icc in use]) if test "$GCC" = "yes"; then dnl check if this is icc acting as gcc in disguise AC_EGREP_CPP([^__INTEL_COMPILER], [__INTEL_COMPILER], AC_MSG_RESULT([no]) [$2], AC_MSG_RESULT([yes]) [$1] ICC="yes") else AC_MSG_RESULT([no]) [$2] fi ]) DETECT_ICC([], []) dnl ********************************************************************** dnl DETECT_CLANG ([ACTION-IF-YES], [ACTION-IF-NO]) dnl dnl check if compiler is clang, and if so run the ACTION-IF-YES sets the dnl $CLANG variable to "yes" or "no" dnl ********************************************************************** AC_DEFUN([DETECT_CLANG], [ AC_MSG_CHECKING([for clang in use]) AC_COMPILE_IFELSE( [AC_LANG_PROGRAM([], [[ #ifndef __clang__ not clang #endif ]])], [CLANG=yes], [CLANG=no]) AC_MSG_RESULT([$CLANG]) AS_IF([test "$CLANG" = "yes"],[$1],[$2]) ]) DETECT_CLANG([],[]) dnl ********************************************************************** dnl DETECT_SUNCC ([ACTION-IF-YES], [ACTION-IF-NO]) dnl dnl check if this is the Sun Studio compiler, and if so run the ACTION-IF-YES dnl sets the $SUNCC variable to "yes" or "no" dnl ********************************************************************** AC_DEFUN([DETECT_SUNCC], [ AC_CHECK_DECL([__SUNPRO_C], [SUNCC="yes"], [SUNCC="no"]) AS_IF(test "x$SUNCC" = "xyes", [$1], [$2]) ]) DETECT_SUNCC([CFLAGS="-mt $CFLAGS"], []) AS_IF([test "$ICC" = "yes" -o "$GCC" = "yes"], [ AS_IF(test "$CLANG" = "no",[CFLAGS="$CFLAGS -pthread"]) ]) dnl clang will error .arch_extension crc32 assembler directives to allow dnl assembling crc instructions without this AS_IF(test "$CLANG" = "yes",[CFLAGS="$CFLAGS -Wno-language-extension-token"]) if test "$ICC" = "no"; then AC_PROG_CC_C99 fi AM_PROG_CC_C_O AC_PROG_INSTALL AC_ARG_ENABLE(extstore, [AS_HELP_STRING([--disable-extstore], [Disable external storage (extstore)])]) AC_ARG_ENABLE(seccomp, [AS_HELP_STRING([--enable-seccomp],[Enable seccomp restrictions EXPERIMENTAL])]) AC_ARG_ENABLE(sasl, [AS_HELP_STRING([--enable-sasl],[Enable SASL authentication])]) AC_ARG_ENABLE(sasl_pwdb, [AS_HELP_STRING([--enable-sasl-pwdb],[Enable plaintext password db])]) AS_IF([test "x$enable_sasl_pwdb" = "xyes"], [enable_sasl=yes ]) AC_ARG_ENABLE(tls, [AS_HELP_STRING([--enable-tls], [Enable Transport Layer Security EXPERIMENTAL ])]) AC_ARG_ENABLE(asan, [AS_HELP_STRING([--enable-asan], [Compile with ASAN EXPERIMENTAL ])]) AC_ARG_ENABLE(static, [AS_HELP_STRING([--enable-static], [Compile a statically linked binary])]) AC_ARG_ENABLE(unix_socket, [AS_HELP_STRING([--disable-unix-socket], [Disable unix domain socket])]) AC_ARG_ENABLE(proxy, [AS_HELP_STRING([--enable-proxy], [Enable proxy code EXPERIMENTAL])]) AC_ARG_ENABLE(proxy-uring, [AS_HELP_STRING([--enable-proxy-uring], [Enable proxy io_uring code EXPERIMENTAL])]) AC_ARG_ENABLE(werror, [AS_HELP_STRING([--enable-werror], [Enable -Werror])]) dnl ********************************************************************** dnl DETECT_SASL_CB_GETCONF dnl dnl check if we can use SASL_CB_GETCONF dnl ********************************************************************** AC_DEFUN([AC_C_DETECT_SASL_CB_GETCONF], [ AC_CACHE_CHECK([for SASL_CB_GETCONF], [ac_cv_c_sasl_cb_getconf], [AC_TRY_COMPILE( [ #include ], [ unsigned long val = SASL_CB_GETCONF; ], [ ac_cv_c_sasl_cb_getconf=yes ], [ ac_cv_c_sasl_cb_getconf=no ]) ]) AS_IF([test "$ac_cv_c_sasl_cb_getconf" = "yes"], [AC_DEFINE([HAVE_SASL_CB_GETCONF], 1, [Set to nonzero if your SASL implementation supports SASL_CB_GETCONF])]) ]) dnl ********************************************************************** dnl DETECT_SASL_CB_GETCONFPATH dnl dnl check if we can use SASL_CB_GETCONFPATH dnl ********************************************************************** AC_DEFUN([AC_C_DETECT_SASL_CB_GETCONFPATH], [ AC_CACHE_CHECK([for SASL_CB_GETCONFPATH], [ac_cv_c_sasl_cb_getconfpath], [AC_TRY_COMPILE( [ #include ], [ unsigned long val = SASL_CB_GETCONFPATH; ], [ ac_cv_c_sasl_cb_getconfpath=yes ], [ ac_cv_c_sasl_cb_getconfpath=no ]) ]) AS_IF([test "$ac_cv_c_sasl_cb_getconfpath" = "yes"], [AC_DEFINE([HAVE_SASL_CB_GETCONFPATH], 1, [Set to nonzero if your SASL implementation supports SASL_CB_GETCONFPATH])]) ]) AC_CHECK_HEADERS([sasl/sasl.h]) if test "x$enable_sasl" = "xyes"; then AC_C_DETECT_SASL_CB_GETCONF AC_C_DETECT_SASL_CB_GETCONFPATH AC_DEFINE([ENABLE_SASL],1,[Set to nonzero if you want to include SASL]) AC_SEARCH_LIBS([sasl_server_init], [sasl2 sasl], [], [ AC_MSG_ERROR([Failed to locate the library containing sasl_server_init]) ]) AS_IF([test "x$enable_sasl_pwdb" = "xyes"], [AC_DEFINE([ENABLE_SASL_PWDB], 1, [Set to nonzero if you want to enable a SASL pwdb])]) fi AC_ARG_ENABLE(dtrace, [AS_HELP_STRING([--enable-dtrace],[Enable dtrace probes])]) if test "x$enable_dtrace" = "xyes"; then AC_PATH_PROG([DTRACE], [dtrace], "no", [/usr/sbin:$PATH]) if test "x$DTRACE" != "xno"; then AC_DEFINE([ENABLE_DTRACE],1,[Set to nonzero if you want to include DTRACE]) build_dtrace=yes $DTRACE -h -o conftest.h -s memcached_dtrace.d 2>/dev/zero if test $? -eq 0 then dtrace_instrument_obj=yes rm conftest.h # on Mac probe id are generated with $ if test "$is_darwin" = "yes"; then CFLAGS="$CFLAGS -Wno-dollar-in-identifier-extension" fi fi if test "`which tr`" = "/usr/ucb/tr"; then AC_MSG_ERROR([Please remove /usr/ucb from your path. See man standards for more info]) fi else AC_MSG_ERROR([Need dtrace binary and OS support.]) fi fi if test "x$enable_extstore" != "xno"; then AC_DEFINE([EXTSTORE],1,[Set to nonzero if you want to enable extstore]) fi if test "x$enable_tls" = "xyes"; then AC_DEFINE([TLS],1,[Set to nonzero if you want to enable TLS]) fi if test "x$enable_asan" = "xyes"; then AC_DEFINE([ASAN],1,[Set to nonzero if you want to compile using ASAN]) fi if test "x$enable_static" = "xyes"; then AC_DEFINE([STATIC],1,[Set to nonzero if you want to compile a statically linked binary]) fi if test "x$enable_unix_socket" = "xno"; then AC_DEFINE([DISABLE_UNIX_SOCKET],1,[Set to nonzero if you want to disable unix domain socket]) fi if test "x$enable_proxy" = "xyes"; then AC_DEFINE([PROXY],1,[Set to nonzero if you want to enable proxy code]) CPPFLAGS="-Ivendor/lua/src -Ivendor/liburing/src/include $CPPFLAGS" dnl lua needs math lib. LIBS="$LIBS -lm -ldl" fi if test "x$enable_proxy_uring" = "xyes"; then AC_DEFINE([HAVE_LIBURING],1,[Set to nonzero if you want to enable proxy uring handling]) CPPFLAGS="-Ivendor/liburing/src/include $CPPFLAGS" fi AM_CONDITIONAL([BUILD_DTRACE],[test "$build_dtrace" = "yes"]) AM_CONDITIONAL([DTRACE_INSTRUMENT_OBJ],[test "$dtrace_instrument_obj" = "yes"]) AM_CONDITIONAL([ENABLE_SASL],[test "$enable_sasl" = "yes"]) AM_CONDITIONAL([ENABLE_EXTSTORE],[test "$enable_extstore" != "no"]) AM_CONDITIONAL([ENABLE_ARM_CRC32],[test "$enable_arm_crc32" = "yes"]) AM_CONDITIONAL([ENABLE_TLS],[test "$enable_tls" = "yes"]) AM_CONDITIONAL([ENABLE_ASAN],[test "$enable_asan" = "yes"]) AM_CONDITIONAL([ENABLE_STATIC],[test "$enable_static" = "yes"]) AM_CONDITIONAL([DISABLE_UNIX_SOCKET],[test "$enable_unix_socket" = "no"]) AM_CONDITIONAL([ENABLE_PROXY],[test "$enable_proxy" = "yes"]) AM_CONDITIONAL([ENABLE_PROXY_URING],[test "$enable_proxy_uring" = "yes"]) AC_SUBST(DTRACE) AC_SUBST(DTRACEFLAGS) AC_SUBST(ENABLE_SASL) AC_SUBST(PROFILER_LDFLAGS) AC_ARG_ENABLE(coverage, [AS_HELP_STRING([--disable-coverage],[Disable code coverage])]) if test "x$enable_coverage" != "xno"; then if test "$GCC" = "yes" -a "$ICC" != "yes" -a "$CLANG" != "yes" then CFLAGS="$CFLAGS -pthread" AC_PATH_PROG([PROFILER], [gcov], "no", [$PATH]) if test "x$PROFILER" != "xno"; then # Issue 97: The existence of gcov doesn't mean we have -lgcov AC_CHECK_LIB(gcov, main, [ PROFILER_FLAGS="-fprofile-arcs -ftest-coverage" PROFILER_LDFLAGS="-lgcov" ], [ PROFILER_FLAGS= PROFILER_LDFLAGS= ]) fi elif test "$SUNCC" = "yes" then AC_PATH_PROG([PROFILER], [tcov], "no", [$PATH]) if test "x$PROFILER" != "xno"; then PROFILER_FLAGS=-xprofile=tcov fi elif test "x$CLANG" != "xno" then AC_PATH_PROG([PROFILER], [gcov], "no", [$PATH]) if test "x$PROFILER" != "xno" then PROFILER_FLAGS="-fprofile-arcs -ftest-coverage" PROFILER_LDFLAGS= fi fi fi AC_SUBST(PROFILER_FLAGS) AC_ARG_ENABLE(64bit, [AS_HELP_STRING([--enable-64bit],[build 64bit version])]) if test "x$enable_64bit" = "xyes" then org_cflags=$CFLAGS CFLAGS=-m64 AC_RUN_IFELSE( [AC_LANG_PROGRAM([], [dnl return sizeof(void*) == 8 ? 0 : 1; ]) ],[ CFLAGS="-m64 $org_cflags" ],[ AC_MSG_ERROR([Don't know how to build a 64-bit object.]) ],[ dnl cross compile AC_MSG_WARN([Assuming no extra CFLAGS are required for cross-compiling 64bit version.]) ]) fi dnl Check if data pointer is 64bit or not AC_CHECK_SIZEOF([void *]) # Issue 213: Search for clock_gettime to help people linking # with a static version of libevent AC_SEARCH_LIBS(clock_gettime, rt) # Issue 214: Search for the network libraries _before_ searching # for libevent (to help people linking with static libevent) AC_SEARCH_LIBS(socket, socket) AC_SEARCH_LIBS(gethostbyname, nsl) trylibeventdir="" AC_ARG_WITH(libevent, [ --with-libevent=PATH Specify path to libevent installation ], [ if test "x$withval" != "xno" ; then trylibeventdir=$withval fi ] ) dnl ------------------------------------------------------ dnl libevent detection. swiped from Tor. modified a bit. LIBEVENT_URL=https://www.monkey.org/~provos/libevent/ AC_CACHE_CHECK([for libevent directory], ac_cv_libevent_dir, [ saved_LIBS="$LIBS" saved_LDFLAGS="$LDFLAGS" saved_CPPFLAGS="$CPPFLAGS" le_found=no for ledir in $trylibeventdir "" $prefix /usr/local ; do LDFLAGS="$saved_LDFLAGS" LIBS="-levent $saved_LIBS" # Skip the directory if it isn't there. if test ! -z "$ledir" -a ! -d "$ledir" ; then continue; fi if test ! -z "$ledir" ; then if test -d "$ledir/lib" ; then LDFLAGS="-L$ledir/lib $LDFLAGS" else LDFLAGS="-L$ledir $LDFLAGS" fi if test -d "$ledir/include" ; then CPPFLAGS="-I$ledir/include $CPPFLAGS" else CPPFLAGS="-I$ledir $CPPFLAGS" fi fi # Can I compile and link it? AC_TRY_LINK([#include #include #include ], [ event_init(); ], [ libevent_linked=yes ], [ libevent_linked=no ]) if test $libevent_linked = yes; then if test ! -z "$ledir" ; then ac_cv_libevent_dir=$ledir _myos=`echo $target_os | cut -f 1 -d .` AS_IF(test "$SUNCC" = "yes" -o "x$_myos" = "xsolaris2", [saved_LDFLAGS="$saved_LDFLAGS -Wl,-R$ledir/lib"], [AS_IF(test "$GCC" = "yes", [saved_LDFLAGS="$saved_LDFLAGS -Wl,-rpath,$ledir/lib"])]) else ac_cv_libevent_dir="(system)" fi le_found=yes break fi done LIBS="$saved_LIBS" LDFLAGS="$saved_LDFLAGS" CPPFLAGS="$saved_CPPFLAGS" if test $le_found = no ; then AC_MSG_ERROR([libevent is required. You can get it from $LIBEVENT_URL If it's already installed, specify its path using --with-libevent=/dir/ ]) fi ]) LIBS="-levent $LIBS" if test $ac_cv_libevent_dir != "(system)"; then if test -d "$ac_cv_libevent_dir/lib" ; then LDFLAGS="-L$ac_cv_libevent_dir/lib $LDFLAGS" le_libdir="$ac_cv_libevent_dir/lib" else LDFLAGS="-L$ac_cv_libevent_dir $LDFLAGS" le_libdir="$ac_cv_libevent_dir" fi if test -d "$ac_cv_libevent_dir/include" ; then CPPFLAGS="-I$ac_cv_libevent_dir/include $CPPFLAGS" else CPPFLAGS="-I$ac_cv_libevent_dir $CPPFLAGS" fi fi AC_RUN_IFELSE( [AC_LANG_PROGRAM([ #include ], [dnl const char *ver = event_get_version(); return (ver != NULL && *ver != '1') ? 0 : 1; ]) ],[ AC_DEFINE(HAVE_LIBEVENT_NEW, 1, [linked to libevent]) ], [ AC_MSG_ERROR([libevent2 is required]) ], [] []) trylibssldir="" AC_ARG_WITH(libssl, [ --with-libssl=PATH Specify path to libssl installation ], [ if test "x$withval" != "xno" ; then trylibssldir=$withval fi ] ) dnl ---------------------------------------------------------------------------- dnl libssl detection. swiped from libevent. modified for openssl detection. PKG_PROG_PKG_CONFIG OPENSSL_URL=https://www.openssl.org/ if test "x$enable_tls" = "xyes"; then PKG_CHECK_MODULES(OPENSSL, openssl, [LIBS="$LIBS $OPENSSL_LIBS" CFLAGS="$CFLAGS $OPENSSL_CFLAGS"], [ AC_CACHE_CHECK([for libssl directory], ac_cv_libssl_dir, [ saved_LIBS="$LIBS" saved_LDFLAGS="$LDFLAGS" saved_CPPFLAGS="$CPPFLAGS" le_found=no for ledir in $trylibssldir "" $prefix /usr/local ; do LDFLAGS="$saved_LDFLAGS" LIBS="-lssl -lcrypto $saved_LIBS" # Skip the directory if it isn't there. if test ! -z "$ledir" -a ! -d "$ledir" ; then continue; fi if test ! -z "$ledir" ; then if test -d "$ledir/lib" ; then LDFLAGS="-L$ledir/lib $LDFLAGS" else LDFLAGS="-L$ledir $LDFLAGS" fi if test -d "$ledir/include" ; then CPPFLAGS="-I$ledir/include $CPPFLAGS" else CPPFLAGS="-I$ledir $CPPFLAGS" fi fi # Can I compile and link it? AC_TRY_LINK([#include #include #include #include ], [ SSL_CTX* ssl_ctx = SSL_CTX_new(TLS_server_method()); assert(OPENSSL_VERSION_NUMBER >= 0x10100000L);], [ libssl_linked=yes ], [ libssl_linked=no ]) if test $libssl_linked = yes; then if test ! -z "$ledir" ; then ac_cv_libssl_dir=$ledir _myos=`echo $target_os | cut -f 1 -d .` AS_IF(test "$SUNCC" = "yes" -o "x$_myos" = "xsolaris2", [saved_LDFLAGS="$saved_LDFLAGS -Wl,-R$ledir/lib"], [AS_IF(test "$GCC" = "yes", [saved_LDFLAGS="$saved_LDFLAGS -Wl,-rpath,$ledir/lib"])]) else ac_cv_libssl_dir="(system)" fi le_found=yes break fi done LIBS="$saved_LIBS" LDFLAGS="$saved_LDFLAGS" CPPFLAGS="$saved_CPPFLAGS" if test $le_found = no ; then AC_MSG_ERROR([libssl (at least version 1.1.0) is required. You can get it from $OPENSSL_URL If it's already installed, specify its path using --with-libssl=/dir/ ]) fi ]) LIBS="-lssl -lcrypto $LIBS" if test $ac_cv_libssl_dir != "(system)"; then if test -d "$ac_cv_libssl_dir/lib" ; then LDFLAGS="-L$ac_cv_libssl_dir/lib $LDFLAGS" le_libdir="$ac_cv_libssl_dir/lib" else LDFLAGS="-L$ac_cv_libssl_dir $LDFLAGS" le_libdir="$ac_cv_libssl_dir" fi if test -d "$ac_cv_libssl_dir/include" ; then CPPFLAGS="-I$ac_cv_libssl_dir/include $CPPFLAGS" else CPPFLAGS="-I$ac_cv_libssl_dir $CPPFLAGS" fi fi ]) fi if test "x$enable_static" = "xyes"; then LIBS="$LIBS -ldl" LDFLAGS="-static $LDFLAGS" fi dnl ---------------------------------------------------------------------------- AC_SEARCH_LIBS(gethugepagesizes, hugetlbfs) AC_HEADER_STDBOOL AH_BOTTOM([#if HAVE_STDBOOL_H #include #else #define bool char #define false 0 #define true 1 #endif ]) AC_CHECK_HEADERS([inttypes.h]) AH_BOTTOM([#ifdef HAVE_INTTYPES_H #include #endif ]) AC_CHECK_HEADERS([sys/auxv.h]) dnl ********************************************************************** dnl Figure out if this system has the stupid sasl_callback_ft dnl ********************************************************************** AC_DEFUN([AC_HAVE_SASL_CALLBACK_FT], [AC_CACHE_CHECK(for sasl_callback_ft, ac_cv_has_sasl_callback_ft, [ AC_TRY_COMPILE([ #ifdef HAVE_SASL_SASL_H #include #include #endif ],[ sasl_callback_ft a_callback; ],[ ac_cv_has_sasl_callback_ft=yes ],[ ac_cv_has_sasl_callback_ft=no ]) ]) if test $ac_cv_has_sasl_callback_ft = yes; then AC_DEFINE(HAVE_SASL_CALLBACK_FT, 1, [we have sasl_callback_ft]) fi ]) AC_HAVE_SASL_CALLBACK_FT dnl ********************************************************************** dnl DETECT_UINT64_SUPPORT dnl dnl check if we can use a uint64_t dnl ********************************************************************** AC_DEFUN([AC_C_DETECT_UINT64_SUPPORT], [ AC_CACHE_CHECK([for print macros for integers (C99 section 7.8.1)], [ac_cv_c_uint64_support], [AC_TRY_COMPILE( [ #ifdef HAVE_INTTYPES_H #include #endif #include ], [ uint64_t val = 0; fprintf(stderr, "%" PRIu64 "\n", val); ], [ ac_cv_c_uint64_support=yes ], [ ac_cv_c_uint64_support=no ]) ]) ]) AC_C_DETECT_UINT64_SUPPORT AS_IF([test "x$ac_cv_c_uint64_support" = "xno"], [AC_MSG_WARN([ Failed to use print macros (PRIu) as defined in C99 section 7.8.1. ])]) AC_C_CONST dnl From licq: Copyright (c) 2000 Dirk Mueller dnl Check if the type socklen_t is defined anywhere AC_DEFUN([AC_C_SOCKLEN_T], [AC_CACHE_CHECK(for socklen_t, ac_cv_c_socklen_t, [ AC_TRY_COMPILE([ #include #include ],[ socklen_t foo; ],[ ac_cv_c_socklen_t=yes ],[ ac_cv_c_socklen_t=no ]) ]) if test $ac_cv_c_socklen_t = no; then AC_DEFINE(socklen_t, int, [define to int if socklen_t not available]) fi ]) AC_C_SOCKLEN_T dnl Check if we're a little-endian or a big-endian system, needed by hash code AC_C_BIGENDIAN( [AC_DEFINE(ENDIAN_BIG, 1, [machine is bigendian])], [AC_DEFINE(ENDIAN_LITTLE, 1, [machine is littleendian])], [AC_MSG_ERROR([Cannot detect endianness. Must pass ac_cv_c_bigendian={yes,no} to configure.])]) AC_DEFUN([AC_C_HTONLL], [ AC_MSG_CHECKING([for htonll]) have_htoll="no" AC_TRY_LINK([ #include #include #ifdef HAVE_INTTYPES_H #include */ #endif ], [ return htonll(0); ], [ have_htoll="yes" AC_DEFINE([HAVE_HTONLL], [1], [Have ntohll]) ], [ have_htoll="no" ]) AC_MSG_RESULT([$have_htoll]) ]) AC_C_HTONLL dnl Check whether the user's system supports pthread AC_SEARCH_LIBS(pthread_create, pthread) if test "x$ac_cv_search_pthread_create" = "xno"; then AC_MSG_ERROR([Can't enable threads without the POSIX thread library.]) fi AC_CHECK_FUNCS(mlockall) AC_CHECK_FUNCS(getpagesizes) AC_CHECK_FUNCS(sysconf) AC_CHECK_FUNCS(memcntl) AC_CHECK_FUNCS(clock_gettime) AC_CHECK_FUNCS(preadv) AC_CHECK_FUNCS(pread) AC_CHECK_FUNCS(eventfd) AC_CHECK_FUNCS([accept4], [AC_DEFINE(HAVE_ACCEPT4, 1, [Define to 1 if support accept4])]) AC_CHECK_FUNCS([getopt_long], [AC_DEFINE(HAVE_GETOPT_LONG, 1, [Define to 1 if support getopt_long])]) dnl Need to disable opt for alignment check. GCC is too clever and turns this dnl into wide stores and no cmp under O2. AC_DEFUN([AC_C_ALIGNMENT], [AC_CACHE_CHECK(for alignment, ac_cv_c_alignment, [ AC_RUN_IFELSE( [AC_LANG_PROGRAM([ #include #include #pragma GCC optimize ("O0") ], [ char *buf = malloc(32); uint64_t *ptr = (uint64_t*)(buf+2); // catch sigbus, etc. *ptr = 0x1; // catch unaligned word access (ARM cpus) #ifdef ENDIAN_BIG #define ALIGNMENT 0x02030405 #else #define ALIGNMENT 0x05040302 #endif *(buf + 0) = 1; *(buf + 1) = 2; *(buf + 2) = 3; *(buf + 3) = 4; *(buf + 4) = 5; int* i = (int*)(buf+1); return (ALIGNMENT == *i) ? 0 : 1; ]) ],[ ac_cv_c_alignment=none ],[ ac_cv_c_alignment=need ],[ dnl cross compile ac_cv_c_alignment=maybe ]) ]) AS_IF([test $ac_cv_c_alignment = need], [AC_DEFINE(NEED_ALIGN, 1, [Machine need alignment])]) AS_IF([test $ac_cv_c_alignment = maybe], [AC_MSG_WARN([Assuming aligned access is required when cross-compiling]) AC_DEFINE(NEED_ALIGN, 1, [Machine need alignment])]) ]) AC_C_ALIGNMENT dnl Check for our specific usage of GCC atomics. dnl These were added in 4.1.2, but 32bit OS's may lack shorts and 4.1.2 dnl lacks testable defines. have_gcc_atomics=no AC_MSG_CHECKING(for GCC atomics) AC_TRY_LINK([],[ unsigned short a; unsigned short b; b = __sync_add_and_fetch(&a, 1); b = __sync_sub_and_fetch(&a, 2); ],[have_gcc_atomics=yes AC_DEFINE(HAVE_GCC_ATOMICS, 1, [GCC Atomics available])]) AC_MSG_RESULT($have_gcc_atomics) dnl Check for usage of 64bit atomics dnl 32bit systems shouldn't have these. have_gcc_64atomics=no AC_MSG_CHECKING(for GCC 64bit atomics) AC_TRY_LINK([#include ],[ uint64_t a; uint64_t b; b = __sync_add_and_fetch(&a, 1); b = __sync_sub_and_fetch(&a, 2); ],[have_gcc_64atomics=yes AC_DEFINE(HAVE_GCC_64ATOMICS, 1, [GCC 64bit Atomics available])]) AC_MSG_RESULT($have_gcc_64atomics) dnl Check for the requirements for running memcached with less privileges dnl than the default privilege set. On Solaris we need setppriv and priv.h dnl If you want to add support for other platforms you should check for dnl your requirements, define HAVE_DROP_PRIVILEGES, and make sure you add dnl the source file containing the implementation into memcached_SOURCE dnl in Makefile.am AC_CHECK_FUNCS(setppriv, [ AC_CHECK_HEADER(priv.h, [ AC_DEFINE([HAVE_DROP_PRIVILEGES], 1, [Define this if you have an implementation of drop_privileges()]) build_solaris_privs=yes ], []) ],[]) AS_IF([test "x$enable_seccomp" = "xyes" ], [ AC_CHECK_LIB(seccomp, seccomp_rule_add, [ AC_DEFINE([HAVE_DROP_PRIVILEGES], 1, [Define this if you have an implementation of drop_privileges()]) build_linux_privs=yes AC_DEFINE([HAVE_DROP_WORKER_PRIVILEGES], 1, [Define this if you have an implementation of drop_worker_privileges()]) build_linux_privs=yes ], []) ]) AC_CHECK_FUNCS(pledge, [ AC_CHECK_HEADER(unistd.h, [ AC_DEFINE([HAVE_DROP_PRIVILEGES], 1, [Define this if you have an implementation of drop_privileges()]) build_openbsd_privs=yes ], []) ],[]) AC_CHECK_FUNCS(cap_enter, [ AC_CHECK_HEADER(sys/capsicum.h, [ AC_DEFINE([HAVE_DROP_PRIVILEGES], 1, [Define this if you have an implementation of drop_privileges()]) build_freebsd_privs=yes ], []) ],[]) AC_CHECK_FUNCS(sandbox_init, [ AC_CHECK_HEADER(sandbox.h, [ AC_DEFINE([HAVE_DROP_PRIVILEGES], 1, [Define this if you have an implementation of drop_privileges()]) build_darwin_privs=yes ], []) ],[]) AM_CONDITIONAL([BUILD_SOLARIS_PRIVS],[test "$build_solaris_privs" = "yes"]) AM_CONDITIONAL([BUILD_LINUX_PRIVS],[test "$build_linux_privs" = "yes"]) AM_CONDITIONAL([BUILD_OPENBSD_PRIVS],[test "$build_openbsd_privs" = "yes"]) AM_CONDITIONAL([BUILD_FREEBSD_PRIVS],[test "$build_freebsd_privs" = "yes"]) AM_CONDITIONAL([BUILD_DARWIN_PRIVS],[test "$build_darwin_privs" = "yes"]) AC_ARG_ENABLE(docs, [AS_HELP_STRING([--disable-docs],[Disable documentation generation])]) AC_PATH_PROG([XML2RFC], [xml2rfc], "no") AC_PATH_PROG([XSLTPROC], [xsltproc], "no") AM_CONDITIONAL([BUILD_SPECIFICATIONS], [test "x$enable_docs" != "xno" -a "x$XML2RFC" != "xno" -a "x$XSLTPROC" != "xno"]) if test "x$enable_werror" = "xyes"; then CFLAGS="$CFLAGS -Werror" fi dnl Let the compiler be a bit more picky. Please note that you cannot dnl specify these flags to the compiler before AC_CHECK_FUNCS, because dnl the test program will generate a compilation warning and hence fail dnl to detect the function ;-) if test "$ICC" = "yes" then dnl ICC trying to be gcc. CFLAGS="$CFLAGS -diag-disable 187 -Wall" AC_DEFINE([_GNU_SOURCE],[1],[make sure IOV_MAX is defined]) elif test "$GCC" = "yes" then GCC_VERSION=`$CC -dumpversion` CFLAGS="$CFLAGS -Wall -pedantic -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls" if test "x$enable_asan" = "xyes"; then CFLAGS="$CFLAGS -fsanitize=address" fi case $GCC_VERSION in 4.4.*) CFLAGS="$CFLAGS -fno-strict-aliasing" ;; esac AC_DEFINE([_GNU_SOURCE],[1],[make sure IOV_MAX is defined]) elif test "$SUNCC" = "yes" then CFLAGS="$CFLAGS -errfmt=error -errwarn -errshort=tags" fi AC_CONFIG_FILES(Makefile doc/Makefile) AC_OUTPUT memcached-1.6.20/tls.c0000664000175000017500000002201314340006077011376 00000000000000#include "memcached.h" #ifdef TLS #include "tls.h" #include #include #include #include #ifndef MAXPATHLEN #define MAXPATHLEN 4096 #endif static pthread_mutex_t ssl_ctx_lock = PTHREAD_MUTEX_INITIALIZER; const unsigned ERROR_MSG_SIZE = 64; const size_t SSL_ERROR_MSG_SIZE = 256; void SSL_LOCK() { pthread_mutex_lock(&(ssl_ctx_lock)); } void SSL_UNLOCK(void) { pthread_mutex_unlock(&(ssl_ctx_lock)); } /* * Reads decrypted data from the underlying BIO read buffers, * which reads from the socket. */ ssize_t ssl_read(conn *c, void *buf, size_t count) { assert (c != NULL); /* TODO : document the state machine interactions for SSL_read with non-blocking sockets/ SSL re-negotiations */ return SSL_read(c->ssl, buf, count); } /* * SSL sendmsg implementation. Perform a SSL_write. */ ssize_t ssl_sendmsg(conn *c, struct msghdr *msg, int flags) { assert (c != NULL); size_t buf_remain = settings.ssl_wbuf_size; size_t bytes = 0; size_t to_copy; int i; // ssl_wbuf is pointing to the buffer allocated in the worker thread. assert(c->ssl_wbuf); // TODO: allocate a fix buffer in crawler/logger if they start using // the sendmsg method. Also, set c->ssl_wbuf when the side thread // start owning the connection and reset the pointer in // conn_worker_readd. // Currently this connection would not be served by a different thread // than the one it's assigned. assert(pthread_equal(c->thread->thread_id, pthread_self()) != 0); char *bp = c->ssl_wbuf; for (i = 0; i < msg->msg_iovlen; i++) { size_t len = msg->msg_iov[i].iov_len; to_copy = len < buf_remain ? len : buf_remain; memcpy(bp + bytes, (void*)msg->msg_iov[i].iov_base, to_copy); buf_remain -= to_copy; bytes += to_copy; if (buf_remain == 0) break; } /* TODO : document the state machine interactions for SSL_write with non-blocking sockets/ SSL re-negotiations */ return SSL_write(c->ssl, c->ssl_wbuf, bytes); } /* * Writes data to the underlying BIO write buffers, * which encrypt and write them to the socket. */ ssize_t ssl_write(conn *c, void *buf, size_t count) { assert (c != NULL); return SSL_write(c->ssl, buf, count); } /* * Prints an SSL error into the buff, if there's any. */ static void print_ssl_error(char *buff, size_t len) { unsigned long err; if ((err = ERR_get_error()) != 0) { ERR_error_string_n(err, buff, len); } } /* * Loads server certificates to the SSL context and validate them. * @return whether certificates are successfully loaded and verified or not. * @param error_msg contains the error when unsuccessful. */ static bool load_server_certificates(char **errmsg) { bool success = false; const size_t CRLF_NULLCHAR_LEN = 3; char *error_msg = malloc(MAXPATHLEN + ERROR_MSG_SIZE + SSL_ERROR_MSG_SIZE); size_t errmax = MAXPATHLEN + ERROR_MSG_SIZE + SSL_ERROR_MSG_SIZE - CRLF_NULLCHAR_LEN; if (error_msg == NULL) { *errmsg = NULL; return false; } if (settings.ssl_ctx == NULL) { snprintf(error_msg, errmax, "Error TLS not enabled\r\n"); *errmsg = error_msg; return false; } char *ssl_err_msg = malloc(SSL_ERROR_MSG_SIZE); if (ssl_err_msg == NULL) { free(error_msg); *errmsg = NULL; return false; } bzero(ssl_err_msg, SSL_ERROR_MSG_SIZE); size_t err_msg_size = 0; SSL_LOCK(); if (!SSL_CTX_use_certificate_chain_file(settings.ssl_ctx, settings.ssl_chain_cert)) { print_ssl_error(ssl_err_msg, SSL_ERROR_MSG_SIZE); err_msg_size = snprintf(error_msg, errmax, "Error loading the certificate chain: " "%s : %s", settings.ssl_chain_cert, ssl_err_msg); } else if (!SSL_CTX_use_PrivateKey_file(settings.ssl_ctx, settings.ssl_key, settings.ssl_keyformat)) { print_ssl_error(ssl_err_msg, SSL_ERROR_MSG_SIZE); err_msg_size = snprintf(error_msg, errmax, "Error loading the key: %s : %s", settings.ssl_key, ssl_err_msg); } else if (!SSL_CTX_check_private_key(settings.ssl_ctx)) { print_ssl_error(ssl_err_msg, SSL_ERROR_MSG_SIZE); err_msg_size = snprintf(error_msg, errmax, "Error validating the certificate: %s", ssl_err_msg); } else if (settings.ssl_ca_cert) { if (!SSL_CTX_load_verify_locations(settings.ssl_ctx, settings.ssl_ca_cert, NULL)) { print_ssl_error(ssl_err_msg, SSL_ERROR_MSG_SIZE); err_msg_size = snprintf(error_msg, errmax, "Error loading the CA certificate: %s : %s", settings.ssl_ca_cert, ssl_err_msg); } else { SSL_CTX_set_client_CA_list(settings.ssl_ctx, SSL_load_client_CA_file(settings.ssl_ca_cert)); success = true; } } else { success = true; } SSL_UNLOCK(); free(ssl_err_msg); if (success) { settings.ssl_last_cert_refresh_time = current_time; free(error_msg); } else { *errmsg = error_msg; error_msg += (err_msg_size >= errmax ? errmax - 1: err_msg_size); snprintf(error_msg, CRLF_NULLCHAR_LEN, "\r\n"); // Print if there are more errors and drain the queue. ERR_print_errors_fp(stderr); } return success; } /* * Verify SSL settings and initiates the SSL context. */ int ssl_init(void) { assert(settings.ssl_enabled); // SSL context for the process. All connections will share one // process level context. settings.ssl_ctx = SSL_CTX_new(TLS_server_method()); SSL_CTX_set_min_proto_version(settings.ssl_ctx, settings.ssl_min_version); // The server certificate, private key and validations. char *error_msg; if (!load_server_certificates(&error_msg)) { fprintf(stderr, "%s", error_msg); free(error_msg); exit(EX_USAGE); } // The verification mode of client certificate, default is SSL_VERIFY_PEER. SSL_CTX_set_verify(settings.ssl_ctx, settings.ssl_verify_mode, NULL); if (settings.ssl_ciphers && !SSL_CTX_set_cipher_list(settings.ssl_ctx, settings.ssl_ciphers)) { fprintf(stderr, "Error setting the provided cipher(s): %s\n", settings.ssl_ciphers); exit(EX_USAGE); } // Optional session caching; default disabled. if (settings.ssl_session_cache) { SSL_CTX_sess_set_new_cb(settings.ssl_ctx, ssl_new_session_callback); SSL_CTX_set_session_cache_mode(settings.ssl_ctx, SSL_SESS_CACHE_SERVER); SSL_CTX_set_session_id_context(settings.ssl_ctx, (const unsigned char *) SESSION_ID_CONTEXT, strlen(SESSION_ID_CONTEXT)); } else { SSL_CTX_set_session_cache_mode(settings.ssl_ctx, SSL_SESS_CACHE_OFF); } // Optional kernel TLS offload; default disabled. if (settings.ssl_kernel_tls) { #if defined(SSL_OP_ENABLE_KTLS) SSL_CTX_set_options(settings.ssl_ctx, SSL_OP_ENABLE_KTLS); #else fprintf(stderr, "Kernel TLS offload is not available\n"); exit(EX_USAGE); #endif } #ifdef SSL_OP_NO_RENEGOTIATION // Disable TLS re-negotiation if SSL_OP_NO_RENEGOTIATION is defined for // openssl 1.1.0h or above SSL_CTX_set_options(settings.ssl_ctx, SSL_OP_NO_RENEGOTIATION); #endif // Release TLS read/write buffers of idle connections SSL_CTX_set_mode(settings.ssl_ctx, SSL_MODE_RELEASE_BUFFERS); return 0; } /* * This method is registered with each SSL connection and abort the SSL session * if a client initiates a renegotiation for openssl versions before 1.1.0h. * For openssl 1.1.0h and above, TLS re-negotiation is disabled by setting the * SSL_OP_NO_RENEGOTIATION option in SSL_CTX_set_options. */ void ssl_callback(const SSL *s, int where, int ret) { #ifndef SSL_OP_NO_RENEGOTIATION SSL* ssl = (SSL*)s; if (SSL_in_before(ssl)) { fprintf(stderr, "%d: SSL renegotiation is not supported, " "closing the connection\n", SSL_get_fd(ssl)); SSL_set_shutdown(ssl, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN); return; } #endif } /* * This method is invoked with every new successfully negotiated SSL session, * when server-side session caching is enabled. Note that this method is not * invoked when a session is reused. */ int ssl_new_session_callback(SSL *s, SSL_SESSION *sess) { STATS_LOCK(); stats.ssl_new_sessions++; STATS_UNLOCK(); return 0; } bool refresh_certs(char **errmsg) { return load_server_certificates(errmsg); } const char *ssl_proto_text(int version) { switch (version) { case TLS1_VERSION: return "tlsv1.0"; case TLS1_1_VERSION: return "tlsv1.1"; case TLS1_2_VERSION: return "tlsv1.2"; #if defined(TLS1_3_VERSION) case TLS1_3_VERSION: return "tlsv1.3"; #endif default: return "unknown"; } } #endif memcached-1.6.20/util.h0000664000175000017500000000246314204760331011564 00000000000000#include "config.h" /* fast-enough functions for uriencoding strings. */ void uriencode_init(void); bool uriencode(const char *src, char *dst, const size_t srclen, const size_t dstlen); /* * Wrappers around strtoull/strtoll that are safer and easier to * use. For tests and assumptions, see internal_tests.c. * * str a NULL-terminated base decimal 10 unsigned integer * out out parameter, if conversion succeeded * * returns true if conversion succeeded. */ bool safe_strtoull(const char *str, uint64_t *out); bool safe_strtoull_hex(const char *str, uint64_t *out); bool safe_strtoll(const char *str, int64_t *out); bool safe_strtoul(const char *str, uint32_t *out); bool safe_strtol(const char *str, int32_t *out); bool safe_strtod(const char *str, double *out); bool safe_strcpy(char *dst, const char *src, const size_t dstmax); bool safe_memcmp(const void *a, const void *b, size_t len); #ifndef HAVE_HTONLL extern uint64_t htonll(uint64_t); extern uint64_t ntohll(uint64_t); #endif #ifdef __GCC # define __gcc_attribute__ __attribute__ #else # define __gcc_attribute__(x) #endif /** * Vararg variant of perror that makes for more useful error messages * when reporting with parameters. * * @param fmt a printf format */ void vperror(const char *fmt, ...) __gcc_attribute__ ((format (printf, 1, 2))); memcached-1.6.20/config.h.in0000664000175000017500000001237414427544305012473 00000000000000/* config.h.in. Generated from configure.ac by autoheader. */ /* Define if building universal (internal helper macro) */ #undef AC_APPLE_UNIVERSAL_BUILD /* Set to nonzero if you want to compile using ASAN */ #undef ASAN /* Set to nonzero if you want to disable unix domain socket */ #undef DISABLE_UNIX_SOCKET /* Set to nonzero if you want to include DTRACE */ #undef ENABLE_DTRACE /* Set to nonzero if you want to include SASL */ #undef ENABLE_SASL /* Set to nonzero if you want to enable a SASL pwdb */ #undef ENABLE_SASL_PWDB /* machine is bigendian */ #undef ENDIAN_BIG /* machine is littleendian */ #undef ENDIAN_LITTLE /* Set to nonzero if you want to enable extstore */ #undef EXTSTORE /* Define to 1 if support accept4 */ #undef HAVE_ACCEPT4 /* Define to 1 if you have the `cap_enter' function. */ #undef HAVE_CAP_ENTER /* Define to 1 if you have the `clock_gettime' function. */ #undef HAVE_CLOCK_GETTIME /* Define this if you have an implementation of drop_privileges() */ #undef HAVE_DROP_PRIVILEGES /* Define this if you have an implementation of drop_worker_privileges() */ #undef HAVE_DROP_WORKER_PRIVILEGES /* Define to 1 if you have the `eventfd' function. */ #undef HAVE_EVENTFD /* GCC 64bit Atomics available */ #undef HAVE_GCC_64ATOMICS /* GCC Atomics available */ #undef HAVE_GCC_ATOMICS /* Define to 1 if support getopt_long */ #undef HAVE_GETOPT_LONG /* Define to 1 if you have the `getpagesizes' function. */ #undef HAVE_GETPAGESIZES /* Have ntohll */ #undef HAVE_HTONLL /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H /* linked to libevent */ #undef HAVE_LIBEVENT_NEW /* Set to nonzero if you want to enable proxy uring handling */ #undef HAVE_LIBURING /* Define to 1 if you have the `memcntl' function. */ #undef HAVE_MEMCNTL /* Define to 1 if you have the `mlockall' function. */ #undef HAVE_MLOCKALL /* Define to 1 if you have the `pledge' function. */ #undef HAVE_PLEDGE /* Define to 1 if you have the `pread' function. */ #undef HAVE_PREAD /* Define to 1 if you have the `preadv' function. */ #undef HAVE_PREADV /* Define to 1 if you have the `sandbox_init' function. */ #undef HAVE_SANDBOX_INIT /* we have sasl_callback_ft */ #undef HAVE_SASL_CALLBACK_FT /* Set to nonzero if your SASL implementation supports SASL_CB_GETCONF */ #undef HAVE_SASL_CB_GETCONF /* Set to nonzero if your SASL implementation supports SASL_CB_GETCONFPATH */ #undef HAVE_SASL_CB_GETCONFPATH /* Define to 1 if you have the header file. */ #undef HAVE_SASL_SASL_H /* Define to 1 if you have the `setppriv' function. */ #undef HAVE_SETPPRIV /* Define to 1 if stdbool.h conforms to C99. */ #undef HAVE_STDBOOL_H /* Define to 1 if you have the header file. */ #undef HAVE_STDINT_H /* Define to 1 if you have the header file. */ #undef HAVE_STDIO_H /* Define to 1 if you have the header file. */ #undef HAVE_STDLIB_H /* Define to 1 if you have the header file. */ #undef HAVE_STRINGS_H /* Define to 1 if you have the header file. */ #undef HAVE_STRING_H /* Define to 1 if you have the `sysconf' function. */ #undef HAVE_SYSCONF /* Define to 1 if you have the header file. */ #undef HAVE_SYS_AUXV_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_STAT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H /* Define to 1 if the system has the type `_Bool'. */ #undef HAVE__BOOL /* Machine need alignment */ #undef NEED_ALIGN /* Name of package */ #undef PACKAGE /* Define to the address where bug reports for this package should be sent. */ #undef PACKAGE_BUGREPORT /* Define to the full name of this package. */ #undef PACKAGE_NAME /* Define to the full name and version of this package. */ #undef PACKAGE_STRING /* Define to the one symbol short name of this package. */ #undef PACKAGE_TARNAME /* Define to the home page for this package. */ #undef PACKAGE_URL /* Define to the version of this package. */ #undef PACKAGE_VERSION /* Set to nonzero if you want to enable proxy code */ #undef PROXY /* The size of `void *', as computed by sizeof. */ #undef SIZEOF_VOID_P /* Set to nonzero if you want to compile a statically linked binary */ #undef STATIC /* Define to 1 if all of the C90 standard headers exist (not just the ones required in a freestanding environment). This macro is provided for backward compatibility; new code need not use it. */ #undef STDC_HEADERS /* Set to nonzero if you want to enable TLS */ #undef TLS /* Version number of package */ #undef VERSION /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel). */ #if defined AC_APPLE_UNIVERSAL_BUILD # if defined __BIG_ENDIAN__ # define WORDS_BIGENDIAN 1 # endif #else # ifndef WORDS_BIGENDIAN # undef WORDS_BIGENDIAN # endif #endif /* make sure IOV_MAX is defined */ #undef _GNU_SOURCE /* Define to empty if `const' does not conform to ANSI C. */ #undef const /* define to int if socklen_t not available */ #undef socklen_t #if HAVE_STDBOOL_H #include #else #define bool char #define false 0 #define true 1 #endif #ifdef HAVE_INTTYPES_H #include #endif memcached-1.6.20/proto_proxy.c0000664000175000017500000011460714427543277013231 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ /* * Functions for handling the proxy layer. wraps text protocols * * NOTE: many lua functions generate pointers via "lua_newuserdatauv" or * similar. Normal memory checking isn't done as lua will throw a high level * error if malloc fails. Must keep this in mind while allocating data so any * manually malloc'ed information gets freed properly. */ #include "proxy.h" #define PROCESS_MULTIGET true #define PROCESS_NORMAL false static void proxy_process_command(conn *c, char *command, size_t cmdlen, bool multiget); static void mcp_queue_io(conn *c, mc_resp *resp, int coro_ref, lua_State *Lc); /******** EXTERNAL FUNCTIONS ******/ // functions starting with _ are breakouts for the public functions. bool proxy_bufmem_checkadd(LIBEVENT_THREAD *t, int len) { bool oom = false; pthread_mutex_lock(&t->proxy_limit_lock); if (t->proxy_buffer_memory_used > t->proxy_buffer_memory_limit) { oom = true; } else { t->proxy_buffer_memory_used += len; } pthread_mutex_unlock(&t->proxy_limit_lock); return oom; } // see also: process_extstore_stats() void proxy_stats(void *arg, ADD_STAT add_stats, conn *c) { if (arg == NULL) { return; } proxy_ctx_t *ctx = arg; STAT_L(ctx); APPEND_STAT("proxy_config_reloads", "%llu", (unsigned long long)ctx->global_stats.config_reloads); APPEND_STAT("proxy_config_reload_fails", "%llu", (unsigned long long)ctx->global_stats.config_reload_fails); APPEND_STAT("proxy_backend_total", "%llu", (unsigned long long)ctx->global_stats.backend_total); APPEND_STAT("proxy_backend_marked_bad", "%llu", (unsigned long long)ctx->global_stats.backend_marked_bad); APPEND_STAT("proxy_backend_failed", "%llu", (unsigned long long)ctx->global_stats.backend_failed); STAT_UL(ctx); } void process_proxy_stats(void *arg, ADD_STAT add_stats, conn *c) { char key_str[STAT_KEY_LEN]; struct proxy_int_stats istats = {0}; uint64_t req_limit = 0; uint64_t buffer_memory_limit = 0; uint64_t buffer_memory_used = 0; if (!arg) { return; } proxy_ctx_t *ctx = arg; STAT_L(ctx); req_limit = ctx->active_req_limit; buffer_memory_limit = ctx->buffer_memory_limit; // prepare aggregated counters. struct proxy_user_stats *us = &ctx->user_stats; uint64_t counters[us->num_stats]; memset(counters, 0, sizeof(counters)); // TODO (v3): more globals to remove and/or change API method. // aggregate worker thread counters. for (int x = 0; x < settings.num_threads; x++) { LIBEVENT_THREAD *t = get_worker_thread(x); struct proxy_user_stats *tus = t->proxy_user_stats; struct proxy_int_stats *is = t->proxy_int_stats; WSTAT_L(t); for (int i = 0; i < CMD_FINAL; i++) { istats.counters[i] += is->counters[i]; } if (tus && tus->num_stats >= us->num_stats) { for (int i = 0; i < us->num_stats; i++) { counters[i] += tus->counters[i]; } } WSTAT_UL(t); pthread_mutex_lock(&t->proxy_limit_lock); buffer_memory_used += t->proxy_buffer_memory_used; pthread_mutex_unlock(&t->proxy_limit_lock); } // return all of the user generated stats for (int x = 0; x < us->num_stats; x++) { if (us->names[x]) { snprintf(key_str, STAT_KEY_LEN-1, "user_%s", us->names[x]); APPEND_STAT(key_str, "%llu", (unsigned long long)counters[x]); } } STAT_UL(ctx); if (buffer_memory_limit == UINT64_MAX) { buffer_memory_limit = 0; } else { buffer_memory_limit *= settings.num_threads; } if (req_limit == UINT64_MAX) { req_limit = 0; } else { req_limit *= settings.num_threads; } // return proxy counters APPEND_STAT("active_req_limit", "%llu", (unsigned long long)req_limit); APPEND_STAT("buffer_memory_limit", "%llu", (unsigned long long)buffer_memory_limit); APPEND_STAT("buffer_memory_used", "%llu", (unsigned long long)buffer_memory_used); APPEND_STAT("cmd_mg", "%llu", (unsigned long long)istats.counters[CMD_MG]); APPEND_STAT("cmd_ms", "%llu", (unsigned long long)istats.counters[CMD_MS]); APPEND_STAT("cmd_md", "%llu", (unsigned long long)istats.counters[CMD_MD]); APPEND_STAT("cmd_mn", "%llu", (unsigned long long)istats.counters[CMD_MN]); APPEND_STAT("cmd_ma", "%llu", (unsigned long long)istats.counters[CMD_MA]); APPEND_STAT("cmd_me", "%llu", (unsigned long long)istats.counters[CMD_ME]); APPEND_STAT("cmd_get", "%llu", (unsigned long long)istats.counters[CMD_GET]); APPEND_STAT("cmd_gat", "%llu", (unsigned long long)istats.counters[CMD_GAT]); APPEND_STAT("cmd_set", "%llu", (unsigned long long)istats.counters[CMD_SET]); APPEND_STAT("cmd_add", "%llu", (unsigned long long)istats.counters[CMD_ADD]); APPEND_STAT("cmd_cas", "%llu", (unsigned long long)istats.counters[CMD_CAS]); APPEND_STAT("cmd_gets", "%llu", (unsigned long long)istats.counters[CMD_GETS]); APPEND_STAT("cmd_gats", "%llu", (unsigned long long)istats.counters[CMD_GATS]); APPEND_STAT("cmd_incr", "%llu", (unsigned long long)istats.counters[CMD_INCR]); APPEND_STAT("cmd_decr", "%llu", (unsigned long long)istats.counters[CMD_DECR]); APPEND_STAT("cmd_touch", "%llu", (unsigned long long)istats.counters[CMD_TOUCH]); APPEND_STAT("cmd_append", "%llu", (unsigned long long)istats.counters[CMD_APPEND]); APPEND_STAT("cmd_prepend", "%llu", (unsigned long long)istats.counters[CMD_PREPEND]); APPEND_STAT("cmd_delete", "%llu", (unsigned long long)istats.counters[CMD_DELETE]); APPEND_STAT("cmd_replace", "%llu", (unsigned long long)istats.counters[CMD_REPLACE]); } // start the centralized lua state and config thread. void *proxy_init(bool use_uring) { proxy_ctx_t *ctx = calloc(1, sizeof(proxy_ctx_t)); ctx->use_uring = use_uring; pthread_mutex_init(&ctx->config_lock, NULL); pthread_cond_init(&ctx->config_cond, NULL); pthread_mutex_init(&ctx->worker_lock, NULL); pthread_cond_init(&ctx->worker_cond, NULL); pthread_mutex_init(&ctx->manager_lock, NULL); pthread_cond_init(&ctx->manager_cond, NULL); pthread_mutex_init(&ctx->stats_lock, NULL); ctx->active_req_limit = UINT64_MAX; ctx->buffer_memory_limit = UINT64_MAX; // FIXME (v2): default defines. ctx->tunables.tcp_keepalive = false; ctx->tunables.backend_failure_limit = 3; ctx->tunables.connect.tv_sec = 5; ctx->tunables.retry.tv_sec = 3; ctx->tunables.read.tv_sec = 3; STAILQ_INIT(&ctx->manager_head); lua_State *L = luaL_newstate(); ctx->proxy_state = L; luaL_openlibs(L); // NOTE: might need to differentiate the libs yes? proxy_register_libs(ctx, NULL, L); // Create/start the IO thread, which we need before servers // start getting created. proxy_event_thread_t *t = calloc(1, sizeof(proxy_event_thread_t)); ctx->proxy_io_thread = t; proxy_init_event_thread(t, ctx, NULL); pthread_create(&t->thread_id, NULL, proxy_event_thread, t); thread_setname(t->thread_id, "mc-prx-io"); _start_proxy_config_threads(ctx); return ctx; } // Initialize the VM for an individual worker thread. void proxy_thread_init(void *ctx, LIBEVENT_THREAD *thr) { assert(ctx != NULL); assert(thr != NULL); // Create the hook table. thr->proxy_hooks = calloc(CMD_SIZE, sizeof(struct proxy_hook)); if (thr->proxy_hooks == NULL) { fprintf(stderr, "Failed to allocate proxy hooks\n"); exit(EXIT_FAILURE); } thr->proxy_int_stats = calloc(1, sizeof(struct proxy_int_stats)); if (thr->proxy_int_stats == NULL) { fprintf(stderr, "Failed to allocate proxy thread stats\n"); exit(EXIT_FAILURE); } pthread_mutex_init(&thr->proxy_limit_lock, NULL); thr->proxy_ctx = ctx; // Initialize the lua state. lua_State *L = luaL_newstate(); thr->L = L; luaL_openlibs(L); proxy_register_libs(ctx, thr, L); // TODO: srand on time? do we need to bother? for (int x = 0; x < 3; x++) { thr->proxy_rng[x] = rand(); } // Create a proxy event thread structure to piggyback on the worker. proxy_event_thread_t *t = calloc(1, sizeof(proxy_event_thread_t)); thr->proxy_event_thread = t; proxy_init_event_thread(t, ctx, thr->base); } // ctx_stack is a stack of io_pending_proxy_t's. // head of q->s_ctx is the "newest" request so we must push into the head // of the next queue, as requests are dequeued from the head void proxy_submit_cb(io_queue_t *q) { proxy_event_thread_t *e = ((proxy_ctx_t *)q->ctx)->proxy_io_thread; io_pending_proxy_t *p = q->stack_ctx; io_head_t head; be_head_t w_head; // worker local stack. STAILQ_INIT(&head); STAILQ_INIT(&w_head); // NOTE: responses get returned in the correct order no matter what, since // mc_resp's are linked. // we just need to ensure stuff is parsed off the backend in the correct // order. // So we can do with a single list here, but we need to repair the list as // responses are parsed. (in the req_remaining-- section) // TODO (v2): // - except we can't do that because the deferred IO stack isn't // compatible with queue.h. // So for now we build the secondary list with an STAILQ, which // can be transplanted/etc. while (p) { mcp_backend_t *be; P_DEBUG("%s: queueing req for backend: %p\n", __func__, (void *)p); if (p->is_await) { // need to not count await objects multiple times. if (p->await_background) { P_DEBUG("%s: fast-returning await_background object: %p\n", __func__, (void *)p); // intercept await backgrounds // this call cannot recurse if we're on the worker thread, // since the worker thread has to finish executing this // function in order to pick up the returned IO. q->count++; return_io_pending((io_pending_t *)p); p = p->next; continue; } else if (p->await_first) { q->count++; } // funny workaround: awaiting IOP's don't count toward // resuming a connection, only the completion of the await // condition. } else { q->count++; } be = p->backend; if (be->use_io_thread) { STAILQ_INSERT_HEAD(&head, p, io_next); } else { // emulate some of handler_dequeue() STAILQ_INSERT_HEAD(&be->io_head, p, io_next); if (be->io_next == NULL) { be->io_next = p; } be->depth++; if (!be->stacked) { be->stacked = true; be->be_next.stqe_next = NULL; // paranoia STAILQ_INSERT_TAIL(&w_head, be, be_next); } } p = p->next; } // clear out the submit queue so we can re-queue new IO's inline. q->stack_ctx = NULL; if (!STAILQ_EMPTY(&head)) { P_DEBUG("%s: submitting queue to IO thread\n", __func__); // Transfer request stack to event thread. pthread_mutex_lock(&e->mutex); STAILQ_CONCAT(&e->io_head_in, &head); // No point in holding the lock since we're not doing a cond signal. pthread_mutex_unlock(&e->mutex); // Signal to check queue. #ifdef USE_EVENTFD uint64_t u = 1; // TODO (v2): check result? is it ever possible to get a short write/failure // for an eventfd? if (write(e->event_fd, &u, sizeof(uint64_t)) != sizeof(uint64_t)) { assert(1 == 0); } #else if (write(e->notify_send_fd, "w", 1) <= 0) { assert(1 == 0); } #endif } if (!STAILQ_EMPTY(&w_head)) { P_DEBUG("%s: running inline worker queue\n", __func__); // emulating proxy_event_handler proxy_run_backend_queue(&w_head); } return; } // called from worker thread after an individual IO has been returned back to // the worker thread. Do post-IO run and cleanup work. void proxy_return_cb(io_pending_t *pending) { io_pending_proxy_t *p = (io_pending_proxy_t *)pending; if (p->is_await) { mcplib_await_return(p); } else { lua_State *Lc = p->coro; // in order to resume we need to remove the objects that were // originally returned // what's currently on the top of the stack is what we want to keep. lua_rotate(Lc, 1, 1); // We kept the original results from the yield so lua would not // collect them in the meantime. We can drop those now. lua_settop(Lc, 1); // p can be freed/changed from the call below, so fetch the queue now. io_queue_t *q = conn_io_queue_get(p->c, p->io_queue_type); conn *c = p->c; proxy_run_coroutine(Lc, p->resp, p, c); q->count--; if (q->count == 0) { // call re-add directly since we're already in the worker thread. conn_worker_readd(c); } } } // called from the worker thread as an mc_resp is being freed. // must let go of the coroutine reference if there is one. // caller frees the pending IO. void proxy_finalize_cb(io_pending_t *pending) { io_pending_proxy_t *p = (io_pending_proxy_t *)pending; if (p->io_type == IO_PENDING_TYPE_EXTSTORE) { if (p->hdr_it) { // TODO: lock once, worst case this hashes/locks twice. if (p->miss) { item_unlink(p->hdr_it); } item_remove(p->hdr_it); } } // release our coroutine reference. // TODO (v2): coroutines are reusable in lua 5.4. we can stack this onto a freelist // after a lua_resetthread(Lc) call. if (p->coro_ref) { // Note: lua registry is the same for main thread or a coroutine. luaL_unref(p->coro, LUA_REGISTRYINDEX, p->coro_ref); } return; } int try_read_command_proxy(conn *c) { char *el, *cont; if (c->rbytes == 0) return 0; el = memchr(c->rcurr, '\n', c->rbytes); if (!el) { if (c->rbytes > 1024) { /* * We didn't have a '\n' in the first k. This _has_ to be a * large multiget, if not we should just nuke the connection. */ char *ptr = c->rcurr; while (*ptr == ' ') { /* ignore leading whitespaces */ ++ptr; } if (ptr - c->rcurr > 100 || (strncmp(ptr, "get ", 4) && strncmp(ptr, "gets ", 5))) { conn_set_state(c, conn_closing); return 1; } // ASCII multigets are unbound, so our fixed size rbuf may not // work for this particular workload... For backcompat we'll use a // malloc/realloc/free routine just for this. if (!c->rbuf_malloced) { if (!rbuf_switch_to_malloc(c)) { conn_set_state(c, conn_closing); return 1; } } } return 0; } cont = el + 1; assert(cont <= (c->rcurr + c->rbytes)); c->last_cmd_time = current_time; proxy_process_command(c, c->rcurr, cont - c->rcurr, PROCESS_NORMAL); c->rbytes -= (cont - c->rcurr); c->rcurr = cont; assert(c->rcurr <= (c->rbuf + c->rsize)); return 1; } // Called when a connection is closed while in nread state reading a set // Must only be called with an active coroutine. void proxy_cleanup_conn(conn *c) { assert(c->proxy_coro_ref != 0); LIBEVENT_THREAD *thr = c->thread; lua_State *L = thr->L; luaL_unref(L, LUA_REGISTRYINDEX, c->proxy_coro_ref); c->proxy_coro_ref = 0; WSTAT_DECR(thr, proxy_req_active, 1); } // we buffered a SET of some kind. void complete_nread_proxy(conn *c) { assert(c != NULL); LIBEVENT_THREAD *thr = c->thread; lua_State *L = thr->L; if (c->proxy_coro_ref == 0) { complete_nread_ascii(c); return; } conn_set_state(c, conn_new_cmd); // Grab our coroutine. // Leave the reference alone in case we error out, so the conn cleanup // routine can handle it properly. lua_rawgeti(L, LUA_REGISTRYINDEX, c->proxy_coro_ref); lua_State *Lc = lua_tothread(L, -1); mcp_request_t *rq = luaL_checkudata(Lc, -1, "mcp.request"); // validate the data chunk. if (strncmp((char *)c->item + rq->pr.vlen - 2, "\r\n", 2) != 0) { lua_settop(L, 0); // clear anything remaining on the main thread. // FIXME (v2): need to set noreply false if mset_res, but that's kind // of a weird hack to begin with. Evaluate how to best do that here. out_string(c, "CLIENT_ERROR bad data chunk"); return; } // We move ownership of the c->item buffer from the connection to the // request object here. Else we can double free if the conn closes while // inside nread. rq->pr.vbuf = c->item; c->item = NULL; c->item_malloced = false; luaL_unref(L, LUA_REGISTRYINDEX, c->proxy_coro_ref); c->proxy_coro_ref = 0; pthread_mutex_lock(&thr->proxy_limit_lock); thr->proxy_buffer_memory_used += rq->pr.vlen; pthread_mutex_unlock(&thr->proxy_limit_lock); proxy_run_coroutine(Lc, c->resp, NULL, c); lua_settop(L, 0); // clear anything remaining on the main thread. return; } // Simple error wrapper for common failures. // lua_error() is a jump so this function never returns // for clarity add a 'return' after calls to this. void proxy_lua_error(lua_State *L, const char *s) { lua_pushstring(L, s); lua_error(L); } void proxy_lua_ferror(lua_State *L, const char *fmt, ...) { va_list ap; va_start(ap, fmt); lua_pushfstring(L, fmt, ap); va_end(ap); lua_error(L); } // Need a custom function so we can prefix lua strings easily. void proxy_out_errstring(mc_resp *resp, char *type, const char *str) { size_t len; size_t prefix_len = strlen(type); assert(resp != NULL); resp_reset(resp); // avoid noreply since we're throwing important errors. // Fill response object with static string. len = strlen(str); if ((len + prefix_len + 2) > WRITE_BUFFER_SIZE) { /* ought to be always enough. just fail for simplicity */ str = "SERVER_ERROR output line too long"; len = strlen(str); } char *w = resp->wbuf; memcpy(w, type, prefix_len); w += prefix_len; memcpy(w, str, len); w += len; memcpy(w, "\r\n", 2); resp_add_iov(resp, resp->wbuf, len + prefix_len + 2); return; } // NOTE: See notes in mcp_queue_io; the secondary problem with setting the // noreply mode from the response object is that the proxy can return strings // manually, so we have no way to obey what the original request wanted in // that case. static void _set_noreply_mode(mc_resp *resp, mcp_resp_t *r) { switch (r->mode) { case RESP_MODE_NORMAL: break; case RESP_MODE_NOREPLY: // ascii noreply only threw egregious errors to client if (r->status == MCMC_OK) { resp->skip = true; } break; case RESP_MODE_METAQUIET: if (r->resp.code == MCMC_CODE_END) { resp->skip = true; } else if (r->cmd != CMD_MG && r->resp.code == MCMC_CODE_OK) { // FIXME (v2): mcmc's parser needs to help us out a bit more // here. // This is a broken case in the protocol though; quiet mode // ignores HD for mutations but not get. resp->skip = true; } break; default: assert(1 == 0); } } // this resumes every yielded coroutine (and re-resumes if necessary). // called from the worker thread after responses have been pulled from the // network. // Flow: // - the response object should already be on the coroutine stack. // - fix up the stack. // - run coroutine. // - if LUA_YIELD, we need to swap out the pending IO from its mc_resp then call for a queue // again. // - if LUA_OK finalize the response and return // - else set error into mc_resp. int proxy_run_coroutine(lua_State *Lc, mc_resp *resp, io_pending_proxy_t *p, conn *c) { int nresults = 0; int cores = lua_resume(Lc, NULL, 1, &nresults); size_t rlen = 0; if (cores == LUA_OK) { WSTAT_DECR(c->thread, proxy_req_active, 1); int type = lua_type(Lc, 1); P_DEBUG("%s: coroutine completed. return type: %d\n", __func__, type); if (type == LUA_TUSERDATA) { mcp_resp_t *r = luaL_checkudata(Lc, 1, "mcp.response"); _set_noreply_mode(resp, r); if (r->status != MCMC_OK && r->resp.type != MCMC_RESP_ERRMSG) { proxy_out_errstring(resp, PROXY_SERVER_ERROR, "backend failure"); } else if (r->cresp) { mc_resp *tresp = r->cresp; // The internal cache handler has created a resp we want to swap in // here. It would be fastest to swap *resp's position in the // link but if the set is deep this would instead be slow, so // we copy over details from this temporary resp instead. assert(c != NULL); // So far all we fill is the wbuf and some iov's? so just copy // that + the UDP info? memcpy(resp->wbuf, tresp->wbuf, tresp->iov[0].iov_len); for (int x = 0; x < tresp->iovcnt; x++) { resp->iov[x] = tresp->iov[x]; } resp->iovcnt = tresp->iovcnt; resp->chunked_total = tresp->chunked_total; resp->chunked_data_iov = tresp->chunked_data_iov; // copy UDP headers... resp->request_id = tresp->request_id; resp->udp_sequence = tresp->udp_sequence; resp->udp_total = tresp->udp_total; resp->request_addr = tresp->request_addr; resp->request_addr_size = tresp->request_addr_size; resp->item = tresp->item; // will be populated if not extstore fetch resp->skip = tresp->skip; // we let the mcp_resp gc handler free up tresp and any // associated io_pending's of its own later. } else if (r->buf) { // response set from C. resp->write_and_free = r->buf; resp_add_iov(resp, r->buf, r->blen); r->buf = NULL; } else if (lua_getiuservalue(Lc, 1, 1) != LUA_TNIL) { // uservalue slot 1 is pre-created, so we get TNIL instead of // TNONE when nothing was set into it. const char *s = lua_tolstring(Lc, -1, &rlen); size_t l = rlen > WRITE_BUFFER_SIZE ? WRITE_BUFFER_SIZE : rlen; memcpy(resp->wbuf, s, l); resp_add_iov(resp, resp->wbuf, l); lua_pop(Lc, 1); } else { // Empty response: used for ascii multiget emulation. } } else if (type == LUA_TSTRING) { // response is a raw string from lua. const char *s = lua_tolstring(Lc, 1, &rlen); size_t l = rlen > WRITE_BUFFER_SIZE ? WRITE_BUFFER_SIZE : rlen; memcpy(resp->wbuf, s, l); resp_add_iov(resp, resp->wbuf, l); lua_pop(Lc, 1); } else { proxy_out_errstring(resp, PROXY_SERVER_ERROR, "bad response"); } } else if (cores == LUA_YIELD) { int coro_ref = 0; int yield_type = lua_tointeger(Lc, -1); P_DEBUG("%s: coroutine yielded. return type: %d\n", __func__, yield_type); assert(yield_type != 0); lua_pop(Lc, 1); // need to remove and free the io_pending, since c->resp owns it. // so we call mcp_queue_io() again and let it override the // mc_resp's io_pending object. // // p is not null only when being called from proxy_return_cb(), // a pending IO is returning to resume. if (p != NULL) { coro_ref = p->coro_ref; assert((void *)p == (void *)resp->io_pending); resp->io_pending = NULL; c = p->c; // *p is now dead. do_cache_free(c->thread->io_cache, p); } else { // coroutine object sitting on the _main_ VM right now, so we grab // the reference from there, which also pops it. assert(c != NULL); coro_ref = luaL_ref(c->thread->L, LUA_REGISTRYINDEX); } int res = 0; switch (yield_type) { case MCP_YIELD_AWAIT: mcplib_await_run(c, resp, Lc, coro_ref); break; case MCP_YIELD_POOL: // TODO (v2): c only used for cache alloc? mcp_queue_io(c, resp, coro_ref, Lc); break; case MCP_YIELD_LOCAL: // stack should be: rq, res res = mcplib_internal_run(Lc, c, resp, coro_ref); if (res == 0) { // stack should still be: rq, res // TODO: turn this function into a for loop that re-runs on // certain status codes, to avoid recursive depth here. // // FIXME: this dance with the coroutine reference is // annoying. In this case we immediately resume, so no *io // was generated, so we won't do the above coro_ref swap, so // we'll try to take the coro_ref again and fail. // The ref is only actually used in proxy_await // It should instead be stashed on the top mc_resp object // (ideally removing c->proxy_coro_ref at the same time) // and unref'ed when the resp is cleaned up. lua_rawgeti(c->thread->L, LUA_REGISTRYINDEX, coro_ref); luaL_unref(c->thread->L, LUA_REGISTRYINDEX, coro_ref); proxy_run_coroutine(Lc, resp, NULL, c); } else if (res > 0) { // internal run queued for extstore. } else { assert(res < 0); proxy_out_errstring(resp, PROXY_SERVER_ERROR, "bad request"); } break; default: abort(); } } else { WSTAT_DECR(c->thread, proxy_req_active, 1); P_DEBUG("%s: Failed to run coroutine: %s\n", __func__, lua_tostring(Lc, -1)); LOGGER_LOG(NULL, LOG_PROXYEVENTS, LOGGER_PROXY_ERROR, NULL, lua_tostring(Lc, -1)); proxy_out_errstring(resp, PROXY_SERVER_ERROR, "lua failure"); } return 0; } static void proxy_process_command(conn *c, char *command, size_t cmdlen, bool multiget) { assert(c != NULL); LIBEVENT_THREAD *thr = c->thread; struct proxy_hook *hooks = thr->proxy_hooks; lua_State *L = thr->L; proxy_ctx_t *ctx = thr->proxy_ctx; mcp_parser_t pr = {0}; // Avoid doing resp_start() here, instead do it a bit later or as-needed. // This allows us to hop over to the internal text protocol parser, which // also calls resp_start(). // Tighter integration later should obviate the need for this, it is not a // permanent solution. int ret = process_request(&pr, command, cmdlen); if (ret != 0) { WSTAT_INCR(c->thread, proxy_conn_errors, 1); if (!resp_start(c)) { conn_set_state(c, conn_closing); return; } proxy_out_errstring(c->resp, PROXY_CLIENT_ERROR, "parsing request"); if (ret == -2) { // Kill connection on more critical parse failure. conn_set_state(c, conn_closing); } return; } struct proxy_hook *hook = &hooks[pr.command]; int hook_ref = hook->lua_ref; // if client came from a tagged listener, scan for a more specific hook. // TODO: (v2) avoiding a hash table lookup here, but maybe some other // datastructure would suffice. for 4-8 tags this is perfectly fast. if (c->tag && hook->tagged) { struct proxy_hook_tagged *pht = hook->tagged; while (pht->lua_ref) { if (c->tag == pht->tag) { hook_ref = pht->lua_ref; break; } pht++; } } if (!hook_ref) { // need to pass our command string into the internal handler. // to minimize the code change, this means allowing it to tokenize the // full command. The proxy's indirect parser should be built out to // become common code for both proxy and ascii handlers. // For now this means we have to null-terminate the command string, // then call into text protocol handler. // FIXME (v2): use a ptr or something; don't like this code. if (cmdlen > 1 && command[cmdlen-2] == '\r') { command[cmdlen-2] = '\0'; } else { command[cmdlen-1] = '\0'; } // lets nread_proxy know we're in ascii mode. c->proxy_coro_ref = 0; process_command_ascii(c, command); return; } // If ascii multiget, we turn this into a self-calling loop :( // create new request with next key, call this func again, then advance // original string. // might be better to split this function; the below bits turn into a // function call, then we don't re-process the above bits in the same way? // The way this is detected/passed on is very fragile. if (!multiget && pr.cmd_type == CMD_TYPE_GET && pr.has_space) { uint32_t keyoff = pr.tokens[pr.keytoken]; while (pr.klen != 0) { char temp[KEY_MAX_LENGTH + 30]; char *cur = temp; // Core daemon can abort the entire command if one key is bad, but // we cannot from the proxy. Instead we have to inject errors into // the stream. This should, thankfully, be rare at least. if (pr.klen > KEY_MAX_LENGTH) { if (!resp_start(c)) { conn_set_state(c, conn_closing); return; } proxy_out_errstring(c->resp, PROXY_CLIENT_ERROR, "key too long"); } else { // copy original request up until the original key token. memcpy(cur, pr.request, pr.tokens[pr.keytoken]); cur += pr.tokens[pr.keytoken]; // now copy in our "current" key. memcpy(cur, &pr.request[keyoff], pr.klen); cur += pr.klen; memcpy(cur, "\r\n", 2); cur += 2; *cur = '\0'; P_DEBUG("%s: new multiget sub request: %s [%u/%u]\n", __func__, temp, keyoff, pr.klen); proxy_process_command(c, temp, cur - temp, PROCESS_MULTIGET); } // now advance to the next key. keyoff = _process_request_next_key(&pr); } if (!resp_start(c)) { conn_set_state(c, conn_closing); return; } // The above recursions should have created c->resp's in dispatch // order. // So now we add another one at the end to create the capping END // string. memcpy(c->resp->wbuf, ENDSTR, ENDLEN); resp_add_iov(c->resp, c->resp->wbuf, ENDLEN); return; } // We test the command length all the way down here because multigets can // be very long, and they're chopped up by now. if (cmdlen >= MCP_REQUEST_MAXLEN) { WSTAT_INCR(c->thread, proxy_conn_errors, 1); if (!resp_start(c)) { conn_set_state(c, conn_closing); return; } proxy_out_errstring(c->resp, PROXY_CLIENT_ERROR, "request too long"); conn_set_state(c, conn_closing); return; } if (!resp_start(c)) { conn_set_state(c, conn_closing); return; } // Count requests handled by proxy vs local. // Also batch the counts down this far so we can lock once for the active // counter instead of twice. struct proxy_int_stats *istats = c->thread->proxy_int_stats; uint64_t active_reqs = 0; WSTAT_L(c->thread); istats->counters[pr.command]++; c->thread->stats.proxy_conn_requests++; c->thread->stats.proxy_req_active++; active_reqs = c->thread->stats.proxy_req_active; WSTAT_UL(c->thread); if (active_reqs > ctx->active_req_limit) { proxy_out_errstring(c->resp, PROXY_SERVER_ERROR, "active request limit reached"); WSTAT_DECR(c->thread, proxy_req_active, 1); if (pr.vlen != 0) { c->sbytes = pr.vlen; conn_set_state(c, conn_swallow); } return; } // start a coroutine. // TODO (v2): This can pull a thread from a cache. lua_newthread(L); lua_State *Lc = lua_tothread(L, -1); // leave the thread first on the stack, so we can reference it if needed. // pull the lua hook function onto the stack. lua_rawgeti(Lc, LUA_REGISTRYINDEX, hook_ref); mcp_request_t *rq = mcp_new_request(Lc, &pr, command, cmdlen); if (multiget) { rq->ascii_multiget = true; } // NOTE: option 1) copy c->tag into rq->tag here. // add req:listen_tag() to retrieve in top level route. // TODO (v2): lift this to a post-processor? if (rq->pr.vlen != 0) { c->item = NULL; // Need to add the used memory later due to needing an extra callback // handler on error during nread. bool oom = proxy_bufmem_checkadd(c->thread, 0); // relying on temporary malloc's not having fragmentation if (!oom) { c->item = malloc(rq->pr.vlen); } if (c->item == NULL) { lua_settop(L, 0); proxy_out_errstring(c->resp, PROXY_SERVER_ERROR, "out of memory"); WSTAT_DECR(c->thread, proxy_req_active, 1); c->sbytes = rq->pr.vlen; conn_set_state(c, conn_swallow); return; } c->item_malloced = true; c->ritem = c->item; c->rlbytes = rq->pr.vlen; c->proxy_coro_ref = luaL_ref(L, LUA_REGISTRYINDEX); // pops coroutine. conn_set_state(c, conn_nread); return; } else { conn_set_state(c, conn_new_cmd); } proxy_run_coroutine(Lc, c->resp, NULL, c); lua_settop(L, 0); // clear anything remaining on the main thread. } // analogue for storage_get_item(); add a deferred IO object to the current // connection's response object. stack enough information to write to the // server on the submit callback, and enough to resume the lua state on the // completion callback. static void mcp_queue_io(conn *c, mc_resp *resp, int coro_ref, lua_State *Lc) { io_queue_t *q = conn_io_queue_get(c, IO_QUEUE_PROXY); // stack: request, hash selector. latter just to hold a reference. mcp_request_t *rq = luaL_checkudata(Lc, -1, "mcp.request"); mcp_backend_t *be = rq->be; // Then we push a response object, which we'll re-use later. // reserve one uservalue for a lua-supplied response. mcp_resp_t *r = lua_newuserdatauv(Lc, sizeof(mcp_resp_t), 1); // FIXME (v2): is this memset still necessary? I was using it for // debugging. memset(r, 0, sizeof(mcp_resp_t)); r->buf = NULL; r->blen = 0; r->thread = c->thread; assert(r->thread != NULL); gettimeofday(&r->start, NULL); // Set noreply mode. // TODO (v2): the response "inherits" the request's noreply mode, which isn't // strictly correct; we should inherit based on the request that spawned // the coroutine but the structure doesn't allow that yet. // Should also be able to settle this exact mode from the parser so we // don't have to re-branch here. if (rq->pr.noreply) { if (rq->pr.cmd_type == CMD_TYPE_META) { r->mode = RESP_MODE_METAQUIET; for (int x = 2; x < rq->pr.ntokens; x++) { if (rq->request[rq->pr.tokens[x]] == 'q') { rq->request[rq->pr.tokens[x]] = ' '; } } } else { r->mode = RESP_MODE_NOREPLY; rq->request[rq->pr.reqlen - 3] = 'Y'; } } else { r->mode = RESP_MODE_NORMAL; } r->cmd = rq->pr.command; luaL_getmetatable(Lc, "mcp.response"); lua_setmetatable(Lc, -2); io_pending_proxy_t *p = do_cache_alloc(c->thread->io_cache); if (p == NULL) { WSTAT_INCR(c->thread, proxy_conn_oom, 1); proxy_lua_error(Lc, "out of memory allocating from IO cache"); return; } // this is a re-cast structure, so assert that we never outsize it. assert(sizeof(io_pending_t) >= sizeof(io_pending_proxy_t)); memset(p, 0, sizeof(io_pending_proxy_t)); // set up back references. p->io_queue_type = IO_QUEUE_PROXY; p->thread = c->thread; p->c = c; p->resp = resp; p->client_resp = r; p->flushed = false; p->ascii_multiget = rq->ascii_multiget; p->return_cb = proxy_return_cb; p->finalize_cb = proxy_finalize_cb; resp->io_pending = (io_pending_t *)p; // top of the main thread should be our coroutine. // lets grab a reference to it and pop so it doesn't get gc'ed. p->coro_ref = coro_ref; // we'll drop the pointer to the coro on here to save some CPU // on re-fetching it later. The pointer shouldn't change. p->coro = Lc; // The direct backend object. Lc is holding the reference in the stack p->backend = be; // See #887 for notes. // TODO (v2): hopefully this can be optimized out. strncpy(r->be_name, be->name, MAX_NAMELEN+1); strncpy(r->be_port, be->port, MAX_PORTLEN+1); mcp_request_attach(Lc, rq, p); // link into the batch chain. p->next = q->stack_ctx; q->stack_ctx = p; return; } // Common lua debug command. __attribute__((unused)) void dump_stack(lua_State *L) { int top = lua_gettop(L); int i = 1; fprintf(stderr, "--TOP OF STACK [%d]\n", top); for (; i < top + 1; i++) { int type = lua_type(L, i); // lets find the metatable of this userdata to identify it. if (lua_getmetatable(L, i) != 0) { lua_pushstring(L, "__name"); if (lua_rawget(L, -2) != LUA_TNIL) { fprintf(stderr, "--|%d| [%s] (%s)\n", i, lua_typename(L, type), lua_tostring(L, -1)); lua_pop(L, 2); continue; } lua_pop(L, 2); } if (type == LUA_TSTRING) { fprintf(stderr, "--|%d| [%s] | %s\n", i, lua_typename(L, type), lua_tostring(L, i)); } else { fprintf(stderr, "--|%d| [%s]\n", i, lua_typename(L, type)); } } fprintf(stderr, "-----------------\n"); } memcached-1.6.20/proto_text.c0000664000175000017500000030024314427543277013025 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ /* * Functions for handling the text related protocols, original and meta. */ #include "memcached.h" #include "proto_text.h" // FIXME: only for process_proxy_stats() // - some better/different structure for stats subcommands // would remove this abstraction leak. #include "proto_proxy.h" #include "authfile.h" #include "storage.h" #include "base64.h" #ifdef TLS #include "tls.h" #endif #include #include #define META_SPACE(p) { \ *p = ' '; \ p++; \ } #define META_CHAR(p, c) { \ *p = ' '; \ *(p+1) = c; \ p += 2; \ } // NOTE: being a little casual with the write buffer. // the buffer needs to be sized that the longest possible meta response will // fit. Here we allow the key to fill up to half the write buffer, in case // something terrible has gone wrong. #define META_KEY(p, key, nkey, bin) { \ META_CHAR(p, 'k'); \ if (!bin) { \ memcpy(p, key, nkey); \ p += nkey; \ } else { \ p += base64_encode((unsigned char *) key, nkey, (unsigned char *)p, WRITE_BUFFER_SIZE / 2); \ *p = ' '; \ *(p+1) = 'b'; \ p += 2; \ } \ } typedef struct token_s { char *value; size_t length; } token_t; static void _finalize_mset(conn *c, int nbytes, enum store_item_type ret) { mc_resp *resp = c->resp; item *it = c->item; conn_set_state(c, conn_new_cmd); // information about the response line has been stashed in wbuf. char *p = resp->wbuf + resp->wbytes; char *end = p; // end of the stashed data portion. switch (ret) { case STORED: memcpy(p, "HD", 2); // Only place noreply is used for meta cmds is a nominal response. if (c->noreply) { resp->skip = true; } break; case EXISTS: memcpy(p, "EX", 2); break; case NOT_FOUND: memcpy(p, "NF", 2); break; case NOT_STORED: memcpy(p, "NS", 2); break; default: c->noreply = false; out_string(c, "SERVER_ERROR Unhandled storage type."); return; } p += 2; for (char *fp = resp->wbuf; fp < end; fp++) { switch (*fp) { case 'O': // Copy stashed opaque. META_SPACE(p); while (fp < end && *fp != ' ') { *p = *fp; p++; fp++; } break; case 'k': // Encode the key here instead of earlier to minimize copying. META_KEY(p, ITEM_key(it), it->nkey, (it->it_flags & ITEM_KEY_BINARY)); break; case 'c': // We don't have the CAS until this point, which is why we // generate this line so late. META_CHAR(p, 'c'); p = itoa_u64(c->cas, p); break; case 's': // Get final item size, ie from append/prepend META_CHAR(p, 's'); // If the size changed during append/prepend if (nbytes != 0) { p = itoa_u32(nbytes-2, p); } else { p = itoa_u32(it->nbytes-2, p); } break; default: break; } } memcpy(p, "\r\n", 2); p += 2; // we're offset into wbuf, but good convention to track wbytes. resp->wbytes = p - resp->wbuf; resp_add_iov(resp, end, p - end); } /* * we get here after reading the value in set/add/replace commands. The command * has been stored in c->cmd, and the item is ready in c->item. */ void complete_nread_ascii(conn *c) { assert(c != NULL); item *it = c->item; int comm = c->cmd; enum store_item_type ret; bool is_valid = false; int nbytes = 0; pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.slab_stats[ITEM_clsid(it)].set_cmds++; pthread_mutex_unlock(&c->thread->stats.mutex); if ((it->it_flags & ITEM_CHUNKED) == 0) { if (strncmp(ITEM_data(it) + it->nbytes - 2, "\r\n", 2) == 0) { is_valid = true; } } else { char buf[2]; /* should point to the final item chunk */ item_chunk *ch = (item_chunk *) c->ritem; assert(ch->used != 0); /* :( We need to look at the last two bytes. This could span two * chunks. */ if (ch->used > 1) { buf[0] = ch->data[ch->used - 2]; buf[1] = ch->data[ch->used - 1]; } else { assert(ch->prev); assert(ch->used == 1); buf[0] = ch->prev->data[ch->prev->used - 1]; buf[1] = ch->data[ch->used - 1]; } if (strncmp(buf, "\r\n", 2) == 0) { is_valid = true; } else { assert(1 == 0); } } if (!is_valid) { // metaset mode always returns errors. if (c->mset_res) { c->noreply = false; } out_string(c, "CLIENT_ERROR bad data chunk"); } else { uint64_t cas = 0; c->thread->cur_sfd = c->sfd; // cuddle sfd for logging. ret = store_item(it, comm, c->thread, &nbytes, &cas, c->set_stale); #ifdef ENABLE_DTRACE switch (c->cmd) { case NREAD_ADD: MEMCACHED_COMMAND_ADD(c->sfd, ITEM_key(it), it->nkey, (ret == 1) ? it->nbytes : -1, cas); break; case NREAD_REPLACE: MEMCACHED_COMMAND_REPLACE(c->sfd, ITEM_key(it), it->nkey, (ret == 1) ? it->nbytes : -1, cas); break; case NREAD_APPEND: MEMCACHED_COMMAND_APPEND(c->sfd, ITEM_key(it), it->nkey, (ret == 1) ? it->nbytes : -1, cas); break; case NREAD_PREPEND: MEMCACHED_COMMAND_PREPEND(c->sfd, ITEM_key(it), it->nkey, (ret == 1) ? it->nbytes : -1, cas); break; case NREAD_SET: MEMCACHED_COMMAND_SET(c->sfd, ITEM_key(it), it->nkey, (ret == 1) ? it->nbytes : -1, cas); break; case NREAD_CAS: MEMCACHED_COMMAND_CAS(c->sfd, ITEM_key(it), it->nkey, it->nbytes, cas); break; } #endif if (c->mset_res) { c->cas = cas; _finalize_mset(c, nbytes, ret); } else { switch (ret) { case STORED: out_string(c, "STORED"); break; case EXISTS: out_string(c, "EXISTS"); break; case NOT_FOUND: out_string(c, "NOT_FOUND"); break; case NOT_STORED: out_string(c, "NOT_STORED"); break; default: out_string(c, "SERVER_ERROR Unhandled storage type."); } } } c->set_stale = false; /* force flag to be off just in case */ c->mset_res = false; item_remove(c->item); /* release the c->item reference */ c->item = 0; } #define COMMAND_TOKEN 0 #define SUBCOMMAND_TOKEN 1 #define KEY_TOKEN 1 #define MAX_TOKENS 24 #define WANT_TOKENS(ntokens, min, max) \ do { \ if ((min != -1 && ntokens < min) || (max != -1 && ntokens > max)) { \ out_string(c, "ERROR"); \ return; \ } \ } while (0) #define WANT_TOKENS_OR(ntokens, a, b) \ do { \ if (ntokens != a && ntokens != b) { \ out_string(c, "ERROR"); \ return; \ } \ } while (0) #define WANT_TOKENS_MIN(ntokens, min) \ do { \ if (ntokens < min) { \ out_string(c, "ERROR"); \ return; \ } \ } while (0) /* * Tokenize the command string by replacing whitespace with '\0' and update * the token array tokens with pointer to start of each token and length. * Returns total number of tokens. The last valid token is the terminal * token (value points to the first unprocessed character of the string and * length zero). * * Usage example: * * while(tokenize_command(command, ncommand, tokens, max_tokens) > 0) { * for(int ix = 0; tokens[ix].length != 0; ix++) { * ... * } * ncommand = tokens[ix].value - command; * command = tokens[ix].value; * } */ static size_t tokenize_command(char *command, token_t *tokens, const size_t max_tokens) { char *s, *e; size_t ntokens = 0; assert(command != NULL && tokens != NULL && max_tokens > 1); size_t len = strlen(command); unsigned int i = 0; s = e = command; for (i = 0; i < len; i++) { if (*e == ' ') { if (s != e) { tokens[ntokens].value = s; tokens[ntokens].length = e - s; ntokens++; *e = '\0'; if (ntokens == max_tokens - 1) { e++; s = e; /* so we don't add an extra token */ break; } } s = e + 1; } e++; } if (s != e) { tokens[ntokens].value = s; tokens[ntokens].length = e - s; ntokens++; } /* * If we scanned the whole string, the terminal value pointer is null, * otherwise it is the first unprocessed character. */ tokens[ntokens].value = *e == '\0' ? NULL : e; tokens[ntokens].length = 0; ntokens++; return ntokens; } int try_read_command_asciiauth(conn *c) { token_t tokens[MAX_TOKENS]; size_t ntokens; char *cont = NULL; // TODO: move to another function. if (!c->sasl_started) { char *el; uint32_t size = 0; // impossible for the auth command to be this short. if (c->rbytes < 2) return 0; el = memchr(c->rcurr, '\n', c->rbytes); // If no newline after 1k, getting junk data, close out. if (!el) { if (c->rbytes > 2048) { conn_set_state(c, conn_closing); return 1; } return 0; } // Looking for: "set foo 0 0 N\r\nuser pass\r\n" // key, flags, and ttl are ignored. N is used to see if we have the rest. // so tokenize doesn't walk past into the value. // it's fine to leave the \r in, as strtoul will stop at it. *el = '\0'; ntokens = tokenize_command(c->rcurr, tokens, MAX_TOKENS); // ensure the buffer is consumed. c->rbytes -= (el - c->rcurr) + 1; c->rcurr += (el - c->rcurr) + 1; // final token is a NULL ender, so we have one more than expected. if (ntokens < 6 || strcmp(tokens[0].value, "set") != 0 || !safe_strtoul(tokens[4].value, &size)) { if (!c->resp) { if (!resp_start(c)) { conn_set_state(c, conn_closing); return 1; } } out_string(c, "CLIENT_ERROR unauthenticated"); return 1; } // we don't actually care about the key at all; it can be anything. // we do care about the size of the remaining read. c->rlbytes = size + 2; c->sasl_started = true; // reuse from binprot sasl, but not sasl :) } if (c->rbytes < c->rlbytes) { // need more bytes. return 0; } // Going to respond at this point, so attach a response object. if (!c->resp) { if (!resp_start(c)) { conn_set_state(c, conn_closing); return 1; } } cont = c->rcurr; // advance buffer. no matter what we're stopping. c->rbytes -= c->rlbytes; c->rcurr += c->rlbytes; c->sasl_started = false; // must end with \r\n // NB: I thought ASCII sets also worked with just \n, but according to // complete_nread_ascii only \r\n is valid. if (strncmp(cont + c->rlbytes - 2, "\r\n", 2) != 0) { out_string(c, "CLIENT_ERROR bad command line termination"); return 1; } // payload should be "user pass", so we can use the tokenizer. cont[c->rlbytes - 2] = '\0'; ntokens = tokenize_command(cont, tokens, MAX_TOKENS); if (ntokens < 3) { out_string(c, "CLIENT_ERROR bad authentication token format"); return 1; } if (authfile_check(tokens[0].value, tokens[1].value) == 1) { out_string(c, "STORED"); c->authenticated = true; c->try_read_command = try_read_command_ascii; pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.auth_cmds++; pthread_mutex_unlock(&c->thread->stats.mutex); } else { out_string(c, "CLIENT_ERROR authentication failure"); pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.auth_cmds++; c->thread->stats.auth_errors++; pthread_mutex_unlock(&c->thread->stats.mutex); } return 1; } int try_read_command_ascii(conn *c) { char *el, *cont; if (c->rbytes == 0) return 0; el = memchr(c->rcurr, '\n', c->rbytes); if (!el) { if (c->rbytes > 2048) { /* * We didn't have a '\n' in the first few k. This _has_ to be a * large multiget, if not we should just nuke the connection. */ char *ptr = c->rcurr; while (*ptr == ' ') { /* ignore leading whitespaces */ ++ptr; } if (ptr - c->rcurr > 100 || (strncmp(ptr, "get ", 4) && strncmp(ptr, "gets ", 5))) { conn_set_state(c, conn_closing); return 1; } // ASCII multigets are unbound, so our fixed size rbuf may not // work for this particular workload... For backcompat we'll use a // malloc/realloc/free routine just for this. if (!c->rbuf_malloced) { if (!rbuf_switch_to_malloc(c)) { conn_set_state(c, conn_closing); return 1; } } } return 0; } cont = el + 1; if ((el - c->rcurr) > 1 && *(el - 1) == '\r') { el--; } *el = '\0'; assert(cont <= (c->rcurr + c->rbytes)); c->last_cmd_time = current_time; process_command_ascii(c, c->rcurr); c->rbytes -= (cont - c->rcurr); c->rcurr = cont; assert(c->rcurr <= (c->rbuf + c->rsize)); return 1; } static inline bool set_noreply_maybe(conn *c, token_t *tokens, size_t ntokens) { int noreply_index = ntokens - 2; /* NOTE: this function is not the first place where we are going to send the reply. We could send it instead from process_command() if the request line has wrong number of tokens. However parsing malformed line for "noreply" option is not reliable anyway, so it can't be helped. */ if (tokens[noreply_index].value && strcmp(tokens[noreply_index].value, "noreply") == 0) { c->noreply = true; } return c->noreply; } /* client flags == 0 means use no storage for client flags */ static inline int make_ascii_get_suffix(char *suffix, item *it, bool return_cas, int nbytes) { char *p = suffix; *p = ' '; p++; if (FLAGS_SIZE(it) == 0) { *p = '0'; p++; } else { p = itoa_u32(*((uint32_t *) ITEM_suffix(it)), p); } *p = ' '; p = itoa_u32(nbytes-2, p+1); if (return_cas) { *p = ' '; p = itoa_u64(ITEM_get_cas(it), p+1); } *p = '\r'; *(p+1) = '\n'; *(p+2) = '\0'; return (p - suffix) + 2; } /* ntokens is overwritten here... shrug.. */ static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens, bool return_cas, bool should_touch) { char *key; size_t nkey; item *it; token_t *key_token = &tokens[KEY_TOKEN]; int32_t exptime_int = 0; rel_time_t exptime = 0; bool fail_length = false; assert(c != NULL); mc_resp *resp = c->resp; if (should_touch) { // For get and touch commands, use first token as exptime if (!safe_strtol(tokens[1].value, &exptime_int)) { out_string(c, "CLIENT_ERROR invalid exptime argument"); return; } key_token++; exptime = realtime(EXPTIME_TO_POSITIVE_TIME(exptime_int)); } do { while(key_token->length != 0) { bool overflow; // not used here. key = key_token->value; nkey = key_token->length; if (nkey > KEY_MAX_LENGTH) { fail_length = true; goto stop; } it = limited_get(key, nkey, c->thread, exptime, should_touch, DO_UPDATE, &overflow); if (settings.detail_enabled) { stats_prefix_record_get(key, nkey, NULL != it); } if (it) { /* * Construct the response. Each hit adds three elements to the * outgoing data list: * "VALUE " * key * " " + flags + " " + data length + "\r\n" + data (with \r\n) */ { MEMCACHED_COMMAND_GET(c->sfd, ITEM_key(it), it->nkey, it->nbytes, ITEM_get_cas(it)); int nbytes = it->nbytes;; nbytes = it->nbytes; char *p = resp->wbuf; memcpy(p, "VALUE ", 6); p += 6; memcpy(p, ITEM_key(it), it->nkey); p += it->nkey; p += make_ascii_get_suffix(p, it, return_cas, nbytes); resp_add_iov(resp, resp->wbuf, p - resp->wbuf); #ifdef EXTSTORE if (it->it_flags & ITEM_HDR) { if (storage_get_item(c, it, resp) != 0) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.get_oom_extstore++; pthread_mutex_unlock(&c->thread->stats.mutex); item_remove(it); goto stop; } } else if ((it->it_flags & ITEM_CHUNKED) == 0) { resp_add_iov(resp, ITEM_data(it), it->nbytes); } else { resp_add_chunked_iov(resp, it, it->nbytes); } #else if ((it->it_flags & ITEM_CHUNKED) == 0) { resp_add_iov(resp, ITEM_data(it), it->nbytes); } else { resp_add_chunked_iov(resp, it, it->nbytes); } #endif } if (settings.verbose > 1) { int ii; fprintf(stderr, ">%d sending key ", c->sfd); for (ii = 0; ii < it->nkey; ++ii) { fprintf(stderr, "%c", key[ii]); } fprintf(stderr, "\n"); } /* item_get() has incremented it->refcount for us */ pthread_mutex_lock(&c->thread->stats.mutex); if (should_touch) { c->thread->stats.touch_cmds++; c->thread->stats.slab_stats[ITEM_clsid(it)].touch_hits++; } else { c->thread->stats.lru_hits[it->slabs_clsid]++; c->thread->stats.get_cmds++; } pthread_mutex_unlock(&c->thread->stats.mutex); #ifdef EXTSTORE /* If ITEM_HDR, an io_wrap owns the reference. */ if ((it->it_flags & ITEM_HDR) == 0) { resp->item = it; } #else resp->item = it; #endif } else { pthread_mutex_lock(&c->thread->stats.mutex); if (should_touch) { c->thread->stats.touch_cmds++; c->thread->stats.touch_misses++; } else { c->thread->stats.get_misses++; c->thread->stats.get_cmds++; } MEMCACHED_COMMAND_GET(c->sfd, key, nkey, -1, 0); pthread_mutex_unlock(&c->thread->stats.mutex); } key_token++; if (key_token->length != 0) { if (!resp_start(c)) { goto stop; } resp = c->resp; } } /* * If the command string hasn't been fully processed, get the next set * of tokens. */ if (key_token->value != NULL) { ntokens = tokenize_command(key_token->value, tokens, MAX_TOKENS); key_token = tokens; if (!resp_start(c)) { goto stop; } resp = c->resp; } } while(key_token->value != NULL); stop: if (settings.verbose > 1) fprintf(stderr, ">%d END\n", c->sfd); /* If the loop was terminated because of out-of-memory, it is not reliable to add END\r\n to the buffer, because it might not end in \r\n. So we send SERVER_ERROR instead. */ if (key_token->value != NULL) { // Kill any stacked responses we had. conn_release_items(c); // Start a new response object for the error message. if (!resp_start(c)) { // severe out of memory error. conn_set_state(c, conn_closing); return; } if (fail_length) { out_string(c, "CLIENT_ERROR bad command line format"); } else { out_of_memory(c, "SERVER_ERROR out of memory writing get response"); } } else { // Tag the end token onto the most recent response object. resp_add_iov(resp, "END\r\n", 5); conn_set_state(c, conn_mwrite); } } inline static void process_stats_detail(conn *c, const char *command) { assert(c != NULL); if (strcmp(command, "on") == 0) { settings.detail_enabled = 1; out_string(c, "OK"); } else if (strcmp(command, "off") == 0) { settings.detail_enabled = 0; out_string(c, "OK"); } else if (strcmp(command, "dump") == 0) { int len; char *stats = stats_prefix_dump(&len); write_and_free(c, stats, len); } else { out_string(c, "CLIENT_ERROR usage: stats detail on|off|dump"); } } static void process_stat(conn *c, token_t *tokens, const size_t ntokens) { const char *subcommand = tokens[SUBCOMMAND_TOKEN].value; assert(c != NULL); if (ntokens < 2) { out_string(c, "CLIENT_ERROR bad command line"); return; } if (ntokens == 2) { server_stats(&append_stats, c); (void)get_stats(NULL, 0, &append_stats, c); } else if (strcmp(subcommand, "reset") == 0) { stats_reset(); out_string(c, "RESET"); return; } else if (strcmp(subcommand, "detail") == 0) { /* NOTE: how to tackle detail with binary? */ if (ntokens < 4) process_stats_detail(c, ""); /* outputs the error message */ else process_stats_detail(c, tokens[2].value); /* Output already generated */ return; } else if (strcmp(subcommand, "settings") == 0) { process_stat_settings(&append_stats, c); } else if (strcmp(subcommand, "cachedump") == 0) { char *buf; unsigned int bytes, id, limit = 0; if (!settings.dump_enabled) { out_string(c, "CLIENT_ERROR stats cachedump not allowed"); return; } if (ntokens < 5) { out_string(c, "CLIENT_ERROR bad command line"); return; } if (!safe_strtoul(tokens[2].value, &id) || !safe_strtoul(tokens[3].value, &limit)) { out_string(c, "CLIENT_ERROR bad command line format"); return; } if (id >= MAX_NUMBER_OF_SLAB_CLASSES) { out_string(c, "CLIENT_ERROR Illegal slab id"); return; } buf = item_cachedump(id, limit, &bytes); write_and_free(c, buf, bytes); return; } else if (strcmp(subcommand, "conns") == 0) { process_stats_conns(&append_stats, c); #ifdef EXTSTORE } else if (strcmp(subcommand, "extstore") == 0) { process_extstore_stats(&append_stats, c); #endif #ifdef PROXY } else if (strcmp(subcommand, "proxy") == 0) { process_proxy_stats(settings.proxy_ctx, &append_stats, c); #endif } else { /* getting here means that the subcommand is either engine specific or is invalid. query the engine and see. */ if (get_stats(subcommand, strlen(subcommand), &append_stats, c)) { if (c->stats.buffer == NULL) { out_of_memory(c, "SERVER_ERROR out of memory writing stats"); } else { write_and_free(c, c->stats.buffer, c->stats.offset); c->stats.buffer = NULL; } } else { out_string(c, "ERROR"); } return; } /* append terminator and start the transfer */ append_stats(NULL, 0, NULL, 0, c); if (c->stats.buffer == NULL) { out_of_memory(c, "SERVER_ERROR out of memory writing stats"); } else { write_and_free(c, c->stats.buffer, c->stats.offset); c->stats.buffer = NULL; } } // slow snprintf for debugging purposes. static void process_meta_command(conn *c, token_t *tokens, const size_t ntokens) { assert(c != NULL); if (ntokens < 3 || tokens[KEY_TOKEN].length > KEY_MAX_LENGTH) { out_string(c, "CLIENT_ERROR bad command line format"); return; } char *key = tokens[KEY_TOKEN].value; size_t nkey = tokens[KEY_TOKEN].length; if (ntokens >= 4 && tokens[2].length == 1 && tokens[2].value[0] == 'b') { size_t ret = base64_decode((unsigned char *)key, nkey, (unsigned char *)key, nkey); if (ret == 0) { // failed to decode. out_string(c, "CLIENT_ERROR bad command line format"); return; } nkey = ret; } bool overflow; // not used here. item *it = limited_get(key, nkey, c->thread, 0, false, DONT_UPDATE, &overflow); if (it) { mc_resp *resp = c->resp; size_t total = 0; size_t ret; // similar to out_string(). memcpy(resp->wbuf, "ME ", 3); total += 3; if (it->it_flags & ITEM_KEY_BINARY) { // re-encode from memory rather than copy the original key; // to help give confidence that what in memory is what we asked // for. total += base64_encode((unsigned char *) ITEM_key(it), it->nkey, (unsigned char *)resp->wbuf + total, WRITE_BUFFER_SIZE - total); } else { memcpy(resp->wbuf + total, ITEM_key(it), it->nkey); total += it->nkey; } resp->wbuf[total] = ' '; total++; ret = snprintf(resp->wbuf + total, WRITE_BUFFER_SIZE - (it->nkey + 12), "exp=%d la=%llu cas=%llu fetch=%s cls=%u size=%lu\r\n", (it->exptime == 0) ? -1 : (current_time - it->exptime), (unsigned long long)(current_time - it->time), (unsigned long long)ITEM_get_cas(it), (it->it_flags & ITEM_FETCHED) ? "yes" : "no", ITEM_clsid(it), (unsigned long) ITEM_ntotal(it)); item_remove(it); resp->wbytes = total + ret; resp_add_iov(resp, resp->wbuf, resp->wbytes); conn_set_state(c, conn_new_cmd); } else { out_string(c, "EN"); } pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.meta_cmds++; pthread_mutex_unlock(&c->thread->stats.mutex); } #define MFLAG_MAX_OPT_LENGTH 20 #define MFLAG_MAX_OPAQUE_LENGTH 32 struct _meta_flags { unsigned int has_error :1; // flipped if we found an error during parsing. unsigned int no_update :1; unsigned int locked :1; unsigned int vivify :1; unsigned int la :1; unsigned int hit :1; unsigned int value :1; unsigned int set_stale :1; unsigned int no_reply :1; unsigned int has_cas :1; unsigned int new_ttl :1; unsigned int key_binary:1; char mode; // single character mode switch, common to ms/ma rel_time_t exptime; rel_time_t autoviv_exptime; rel_time_t recache_time; uint32_t client_flags; uint64_t req_cas_id; uint64_t delta; // ma uint64_t initial; // ma }; static int _meta_flag_preparse(token_t *tokens, const size_t start, struct _meta_flags *of, char **errstr) { unsigned int i; size_t ret; int32_t tmp_int; uint8_t seen[127] = {0}; // Start just past the key token. Look at first character of each token. for (i = start; tokens[i].length != 0; i++) { uint8_t o = (uint8_t)tokens[i].value[0]; // zero out repeat flags so we don't over-parse for return data. if (o >= 127 || seen[o] != 0) { *errstr = "CLIENT_ERROR duplicate flag"; return -1; } seen[o] = 1; switch (o) { // base64 decode the key in-place, as the binary should always be // shorter and the conversion code buffers bytes. case 'b': ret = base64_decode((unsigned char *)tokens[KEY_TOKEN].value, tokens[KEY_TOKEN].length, (unsigned char *)tokens[KEY_TOKEN].value, tokens[KEY_TOKEN].length); if (ret == 0) { // Failed to decode *errstr = "CLIENT_ERROR error decoding key"; of->has_error = 1; } tokens[KEY_TOKEN].length = ret; of->key_binary = 1; break; /* Negative exptimes can underflow and end up immortal. realtime() will immediately expire values that are greater than REALTIME_MAXDELTA, but less than process_started, so lets aim for that. */ case 'N': of->locked = 1; of->vivify = 1; if (!safe_strtol(tokens[i].value+1, &tmp_int)) { *errstr = "CLIENT_ERROR bad token in command line format"; of->has_error = 1; } else { of->autoviv_exptime = realtime(EXPTIME_TO_POSITIVE_TIME(tmp_int)); } break; case 'T': of->locked = 1; if (!safe_strtol(tokens[i].value+1, &tmp_int)) { *errstr = "CLIENT_ERROR bad token in command line format"; of->has_error = 1; } else { of->exptime = realtime(EXPTIME_TO_POSITIVE_TIME(tmp_int)); of->new_ttl = true; } break; case 'R': of->locked = 1; if (!safe_strtol(tokens[i].value+1, &tmp_int)) { *errstr = "CLIENT_ERROR bad token in command line format"; of->has_error = 1; } else { of->recache_time = realtime(EXPTIME_TO_POSITIVE_TIME(tmp_int)); } break; case 'l': of->la = 1; of->locked = 1; // need locked to delay LRU bump break; case 'O': case 'P': case 'L': break; case 'k': // known but no special handling case 's': case 't': case 'c': case 'f': break; case 'v': of->value = 1; break; case 'h': of->locked = 1; // need locked to delay LRU bump break; case 'u': of->no_update = 1; break; case 'q': of->no_reply = 1; break; // mset-related. case 'F': if (!safe_strtoul(tokens[i].value+1, &of->client_flags)) { of->has_error = true; } break; case 'C': // mset, mdelete, marithmetic if (!safe_strtoull(tokens[i].value+1, &of->req_cas_id)) { *errstr = "CLIENT_ERROR bad token in command line format"; of->has_error = true; } else { of->has_cas = true; } break; case 'M': // mset and marithmetic mode switch if (tokens[i].length != 2) { *errstr = "CLIENT_ERROR incorrect length for M token"; of->has_error = 1; } else { of->mode = tokens[i].value[1]; } break; case 'J': // marithmetic initial value if (!safe_strtoull(tokens[i].value+1, &of->initial)) { *errstr = "CLIENT_ERROR invalid numeric initial value"; of->has_error = 1; } break; case 'D': // marithmetic delta value if (!safe_strtoull(tokens[i].value+1, &of->delta)) { *errstr = "CLIENT_ERROR invalid numeric delta value"; of->has_error = 1; } break; case 'I': of->set_stale = 1; break; default: // unknown flag, bail. *errstr = "CLIENT_ERROR invalid flag"; return -1; } } return of->has_error ? -1 : 0; } static void process_mget_command(conn *c, token_t *tokens, const size_t ntokens) { char *key; size_t nkey; item *it; unsigned int i = 0; struct _meta_flags of = {0}; // option bitflags. uint32_t hv; // cached hash value for unlocking an item. bool failed = false; bool item_created = false; bool won_token = false; bool ttl_set = false; char *errstr = "CLIENT_ERROR bad command line format"; assert(c != NULL); mc_resp *resp = c->resp; char *p = resp->wbuf; WANT_TOKENS_MIN(ntokens, 3); // FIXME: do we move this check to after preparse? if (tokens[KEY_TOKEN].length > KEY_MAX_LENGTH) { out_errstring(c, "CLIENT_ERROR bad command line format"); return; } // NOTE: final token has length == 0. // KEY_TOKEN == 1. 0 is command. if (ntokens > MFLAG_MAX_OPT_LENGTH) { // TODO: ensure the command tokenizer gives us at least this many out_errstring(c, "CLIENT_ERROR options flags are too long"); return; } // scrubs duplicated options and sets flags for how to load the item. // we pass in the first token that should be a flag. if (_meta_flag_preparse(tokens, 2, &of, &errstr) != 0) { out_errstring(c, errstr); return; } c->noreply = of.no_reply; // Grab key and length after meta preparsing in case it was decoded. key = tokens[KEY_TOKEN].value; nkey = tokens[KEY_TOKEN].length; // TODO: need to indicate if the item was overflowed or not? // I think we do, since an overflow shouldn't trigger an alloc/replace. bool overflow = false; if (!of.locked) { it = limited_get(key, nkey, c->thread, 0, false, !of.no_update, &overflow); } else { // If we had to lock the item, we're doing our own bump later. it = limited_get_locked(key, nkey, c->thread, DONT_UPDATE, &hv, &overflow); } // Since we're a new protocol, we can actually inform users that refcount // overflow is happening by straight up throwing an error. // We definitely don't want to re-autovivify by accident. if (overflow) { assert(it == NULL); out_errstring(c, "SERVER_ERROR refcount overflow during fetch"); return; } if (it == NULL && of.vivify) { // Fill in the exptime during parsing later. it = item_alloc(key, nkey, 0, realtime(0), 2); // We don't actually need any of do_store_item's logic: // - already fetched and missed an existing item. // - lock is still held. // - not append/prepend/replace // - not testing CAS if (it != NULL) { // I look forward to the day I get rid of this :) memcpy(ITEM_data(it), "\r\n", 2); // NOTE: This initializes the CAS value. do_item_link(it, hv); item_created = true; } } // don't have to check result of add_iov() since the iov size defaults are // enough. if (it) { if (of.value) { memcpy(p, "VA ", 3); p = itoa_u32(it->nbytes-2, p+3); } else { memcpy(p, "HD", 2); p += 2; } for (i = KEY_TOKEN+1; i < ntokens-1; i++) { switch (tokens[i].value[0]) { case 'T': ttl_set = true; it->exptime = of.exptime; break; case 'N': if (item_created) { it->exptime = of.autoviv_exptime; won_token = true; } break; case 'R': // If we haven't autovivified and supplied token is less // than current TTL, mark a win. if ((it->it_flags & ITEM_TOKEN_SENT) == 0 && !item_created && it->exptime != 0 && it->exptime < of.recache_time) { won_token = true; } break; case 's': META_CHAR(p, 's'); p = itoa_u32(it->nbytes-2, p); break; case 't': // TTL remaining as of this request. // needs to be relative because server clocks may not be in sync. META_CHAR(p, 't'); if (it->exptime == 0) { *p = '-'; *(p+1) = '1'; p += 2; } else { p = itoa_u32(it->exptime - current_time, p); } break; case 'c': META_CHAR(p, 'c'); p = itoa_u64(ITEM_get_cas(it), p); break; case 'f': META_CHAR(p, 'f'); if (FLAGS_SIZE(it) == 0) { *p = '0'; p++; } else { p = itoa_u32(*((uint32_t *) ITEM_suffix(it)), p); } break; case 'l': META_CHAR(p, 'l'); p = itoa_u32(current_time - it->time, p); break; case 'h': META_CHAR(p, 'h'); if (it->it_flags & ITEM_FETCHED) { *p = '1'; } else { *p = '0'; } p++; break; case 'O': if (tokens[i].length > MFLAG_MAX_OPAQUE_LENGTH) { errstr = "CLIENT_ERROR opaque token too long"; goto error; } META_SPACE(p); memcpy(p, tokens[i].value, tokens[i].length); p += tokens[i].length; break; case 'k': META_KEY(p, ITEM_key(it), it->nkey, (it->it_flags & ITEM_KEY_BINARY)); break; } } // Has this item already sent a token? // Important to do this here so we don't send W with Z. // Isn't critical, but easier for client authors to understand. if (it->it_flags & ITEM_TOKEN_SENT) { META_CHAR(p, 'Z'); } if (it->it_flags & ITEM_STALE) { META_CHAR(p, 'X'); // FIXME: think hard about this. is this a default, or a flag? if ((it->it_flags & ITEM_TOKEN_SENT) == 0) { // If we're stale but no token already sent, now send one. won_token = true; } } if (won_token) { // Mark a win into the flag buffer. META_CHAR(p, 'W'); it->it_flags |= ITEM_TOKEN_SENT; } *p = '\r'; *(p+1) = '\n'; *(p+2) = '\0'; p += 2; // finally, chain in the buffer. resp_add_iov(resp, resp->wbuf, p - resp->wbuf); if (of.value) { #ifdef EXTSTORE if (it->it_flags & ITEM_HDR) { if (storage_get_item(c, it, resp) != 0) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.get_oom_extstore++; pthread_mutex_unlock(&c->thread->stats.mutex); failed = true; } } else if ((it->it_flags & ITEM_CHUNKED) == 0) { resp_add_iov(resp, ITEM_data(it), it->nbytes); } else { resp_add_chunked_iov(resp, it, it->nbytes); } #else if ((it->it_flags & ITEM_CHUNKED) == 0) { resp_add_iov(resp, ITEM_data(it), it->nbytes); } else { resp_add_chunked_iov(resp, it, it->nbytes); } #endif } // need to hold the ref at least because of the key above. #ifdef EXTSTORE if (!failed) { if ((it->it_flags & ITEM_HDR) != 0 && of.value) { // Only have extstore clean if header and returning value. resp->item = NULL; } else { resp->item = it; } } else { // Failed to set up extstore fetch. if (of.locked) { do_item_remove(it); } else { item_remove(it); } } #else resp->item = it; #endif } else { failed = true; } if (of.locked) { // Delayed bump so we could get fetched/last access time pre-update. if (!of.no_update && it != NULL) { do_item_bump(c->thread, it, hv); } item_unlock(hv); } // we count this command as a normal one if we've gotten this far. // TODO: for autovivify case, miss never happens. Is this okay? if (!failed) { pthread_mutex_lock(&c->thread->stats.mutex); if (ttl_set) { c->thread->stats.touch_cmds++; c->thread->stats.slab_stats[ITEM_clsid(it)].touch_hits++; } else { c->thread->stats.lru_hits[it->slabs_clsid]++; c->thread->stats.get_cmds++; } pthread_mutex_unlock(&c->thread->stats.mutex); conn_set_state(c, conn_new_cmd); } else { pthread_mutex_lock(&c->thread->stats.mutex); if (ttl_set) { c->thread->stats.touch_cmds++; c->thread->stats.touch_misses++; } else { c->thread->stats.get_misses++; c->thread->stats.get_cmds++; } MEMCACHED_COMMAND_GET(c->sfd, key, nkey, -1, 0); pthread_mutex_unlock(&c->thread->stats.mutex); // This gets elided in noreply mode. if (c->noreply) resp->skip = true; memcpy(p, "EN", 2); p += 2; for (i = KEY_TOKEN+1; i < ntokens-1; i++) { switch (tokens[i].value[0]) { // TODO: macro perhaps? case 'O': if (tokens[i].length > MFLAG_MAX_OPAQUE_LENGTH) { errstr = "CLIENT_ERROR opaque token too long"; goto error; } META_SPACE(p); memcpy(p, tokens[i].value, tokens[i].length); p += tokens[i].length; break; case 'k': META_KEY(p, key, nkey, of.key_binary); break; } } resp->wbytes = p - resp->wbuf; memcpy(resp->wbuf + resp->wbytes, "\r\n", 2); resp->wbytes += 2; resp_add_iov(resp, resp->wbuf, resp->wbytes); conn_set_state(c, conn_new_cmd); } return; error: if (it) { do_item_remove(it); if (of.locked) { item_unlock(hv); } } out_errstring(c, errstr); } static void process_mset_command(conn *c, token_t *tokens, const size_t ntokens) { char *key; size_t nkey; item *it; int i; short comm = NREAD_SET; struct _meta_flags of = {0}; // option bitflags. char *errstr = "CLIENT_ERROR bad command line format"; uint32_t hv; // cached hash value. int vlen = 0; // value from data line. assert(c != NULL); mc_resp *resp = c->resp; char *p = resp->wbuf; rel_time_t exptime = 0; WANT_TOKENS_MIN(ntokens, 3); // TODO: most of this is identical to mget. if (tokens[KEY_TOKEN].length > KEY_MAX_LENGTH) { out_errstring(c, "CLIENT_ERROR bad command line format"); return; } if (ntokens == 3) { out_errstring(c, "CLIENT_ERROR bad command line format"); return; } if (ntokens > MFLAG_MAX_OPT_LENGTH) { out_errstring(c, "CLIENT_ERROR options flags too long"); return; } // We note tokens into the front of the write buffer, so we can create the // final buffer in complete_nread_ascii. p = resp->wbuf; if (!safe_strtol(tokens[KEY_TOKEN + 1].value, (int32_t*)&vlen)) { out_errstring(c, "CLIENT_ERROR bad command line format"); return; } if (vlen < 0 || vlen > (INT_MAX - 2)) { out_errstring(c, "CLIENT_ERROR bad command line format"); return; } vlen += 2; // We need to at least try to get the size to properly slurp bad bytes // after an error. // we pass in the first token that should be a flag. if (_meta_flag_preparse(tokens, 3, &of, &errstr) != 0) { goto error; } key = tokens[KEY_TOKEN].value; nkey = tokens[KEY_TOKEN].length; // Set noreply after tokens are understood. c->noreply = of.no_reply; // Clear cas return value c->cas = 0; exptime = of.exptime; bool has_error = false; for (i = KEY_TOKEN+1; i < ntokens-1; i++) { switch (tokens[i].value[0]) { // TODO: macro perhaps? case 'O': if (tokens[i].length > MFLAG_MAX_OPAQUE_LENGTH) { errstr = "CLIENT_ERROR opaque token too long"; has_error = true; break; } META_SPACE(p); memcpy(p, tokens[i].value, tokens[i].length); p += tokens[i].length; break; case 'k': META_CHAR(p, 'k'); break; case 'c': // need to set the cas value post-assignment. META_CHAR(p, 'c'); case 's': // get the final size post-fill META_CHAR(p, 's'); break; } } // "mode switch" to alternative commands switch (of.mode) { case 0: break; // no mode supplied. case 'E': // Add... comm = NREAD_ADD; break; case 'A': // Append. if (of.vivify) { comm = NREAD_APPENDVIV; exptime = of.autoviv_exptime; } else { comm = NREAD_APPEND; } break; case 'P': // Prepend. if (of.vivify) { comm = NREAD_PREPENDVIV; exptime = of.autoviv_exptime; } else { comm = NREAD_PREPEND; } break; case 'R': // Replace. comm = NREAD_REPLACE; break; case 'S': // Set. Default. comm = NREAD_SET; break; default: errstr = "CLIENT_ERROR invalid mode for ms M token"; goto error; } // The item storage function doesn't exactly map to mset. // If a CAS value is supplied, upgrade default SET mode to CAS mode. // Also allows REPLACE to work, as REPLACE + CAS works the same as CAS. // add-with-cas works the same as add; but could only LRU bump if match.. // APPEND/PREPEND allow a simplified CAS check. if (of.has_cas && (comm == NREAD_SET || comm == NREAD_REPLACE)) { comm = NREAD_CAS; } // We attempt to process as much as we can in hopes of getting a valid and // adjusted vlen, or else the data swallowed after error will be for 0b. if (has_error) goto error; it = item_alloc(key, nkey, of.client_flags, exptime, vlen); if (it == 0) { enum store_item_type status; // TODO: These could be normalized codes (TL and OM). Need to // reorganize the output stuff a bit though. if (! item_size_ok(nkey, of.client_flags, vlen)) { errstr = "SERVER_ERROR object too large for cache"; status = TOO_LARGE; pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.store_too_large++; pthread_mutex_unlock(&c->thread->stats.mutex); } else { errstr = "SERVER_ERROR out of memory storing object"; status = NO_MEMORY; pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.store_no_memory++; pthread_mutex_unlock(&c->thread->stats.mutex); } // FIXME: LOGGER_LOG specific to mset, include options. LOGGER_LOG(c->thread->l, LOG_MUTATIONS, LOGGER_ITEM_STORE, NULL, status, comm, key, nkey, 0, 0); /* Avoid stale data persisting in cache because we failed alloc. */ // NOTE: only if SET mode? it = item_get_locked(key, nkey, c->thread, DONT_UPDATE, &hv); if (it) { do_item_unlink(it, hv); STORAGE_delete(c->thread->storage, it); do_item_remove(it); } item_unlock(hv); goto error; } ITEM_set_cas(it, of.req_cas_id); c->item = it; #ifdef NEED_ALIGN if (it->it_flags & ITEM_CHUNKED) { c->ritem = ITEM_schunk(it); } else { c->ritem = ITEM_data(it); } #else c->ritem = ITEM_data(it); #endif c->rlbytes = it->nbytes; c->cmd = comm; // Prevent printing back the key in meta commands as garbage. if (of.key_binary) { it->it_flags |= ITEM_KEY_BINARY; } if (of.set_stale && comm == NREAD_CAS) { c->set_stale = true; } resp->wbytes = p - resp->wbuf; // we don't set up the iov here, instead after complete_nread_ascii when // we have the full status code and item data. c->mset_res = true; conn_set_state(c, conn_nread); return; error: /* swallow the data line */ c->sbytes = vlen; // Note: no errors possible after the item was successfully allocated. // So we're just looking at dumping error codes and returning. out_errstring(c, errstr); // TODO: pass state in? else switching twice meh. conn_set_state(c, conn_swallow); } static void process_mdelete_command(conn *c, token_t *tokens, const size_t ntokens) { char *key; size_t nkey; item *it = NULL; int i; uint32_t hv; struct _meta_flags of = {0}; // option bitflags. char *errstr = "CLIENT_ERROR bad command line format"; assert(c != NULL); mc_resp *resp = c->resp; // reserve bytes for status code char *p = resp->wbuf + 2; WANT_TOKENS_MIN(ntokens, 3); // TODO: most of this is identical to mget. if (tokens[KEY_TOKEN].length > KEY_MAX_LENGTH) { out_string(c, "CLIENT_ERROR bad command line format"); return; } if (ntokens > MFLAG_MAX_OPT_LENGTH) { out_string(c, "CLIENT_ERROR options flags too long"); return; } // scrubs duplicated options and sets flags for how to load the item. // we pass in the first token that should be a flag. // FIXME: not using the preparse errstr? if (_meta_flag_preparse(tokens, 2, &of, &errstr) != 0) { out_errstring(c, "CLIENT_ERROR invalid or duplicate flag"); return; } assert(c != NULL); c->noreply = of.no_reply; key = tokens[KEY_TOKEN].value; nkey = tokens[KEY_TOKEN].length; for (i = KEY_TOKEN+1; i < ntokens-1; i++) { switch (tokens[i].value[0]) { // TODO: macro perhaps? case 'O': if (tokens[i].length > MFLAG_MAX_OPAQUE_LENGTH) { errstr = "CLIENT_ERROR opaque token too long"; goto error; } META_SPACE(p); memcpy(p, tokens[i].value, tokens[i].length); p += tokens[i].length; break; case 'k': META_KEY(p, key, nkey, of.key_binary); break; } } it = item_get_locked(key, nkey, c->thread, DONT_UPDATE, &hv); if (it) { MEMCACHED_COMMAND_DELETE(c->sfd, ITEM_key(it), it->nkey); // allow only deleting/marking if a CAS value matches. if (of.has_cas && ITEM_get_cas(it) != of.req_cas_id) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.delete_misses++; pthread_mutex_unlock(&c->thread->stats.mutex); memcpy(resp->wbuf, "EX", 2); goto cleanup; } // If we're to set this item as stale, we don't actually want to // delete it. We mark the stale bit, bump CAS, and update exptime if // we were supplied a new TTL. if (of.set_stale) { if (of.new_ttl) { it->exptime = of.exptime; } it->it_flags |= ITEM_STALE; // Also need to remove TOKEN_SENT, so next client can win. it->it_flags &= ~ITEM_TOKEN_SENT; ITEM_set_cas(it, (settings.use_cas) ? get_cas_id() : 0); // Clients can noreply nominal responses. if (c->noreply) resp->skip = true; memcpy(resp->wbuf, "HD", 2); } else { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.slab_stats[ITEM_clsid(it)].delete_hits++; pthread_mutex_unlock(&c->thread->stats.mutex); LOGGER_LOG(NULL, LOG_DELETIONS, LOGGER_DELETIONS, it, LOG_TYPE_META_DELETE); do_item_unlink(it, hv); STORAGE_delete(c->thread->storage, it); if (c->noreply) resp->skip = true; memcpy(resp->wbuf, "HD", 2); } goto cleanup; } else { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.delete_misses++; pthread_mutex_unlock(&c->thread->stats.mutex); memcpy(resp->wbuf, "NF", 2); goto cleanup; } cleanup: if (it) { do_item_remove(it); } // Item is always returned locked, even if missing. item_unlock(hv); resp->wbytes = p - resp->wbuf; memcpy(resp->wbuf + resp->wbytes, "\r\n", 2); resp->wbytes += 2; resp_add_iov(resp, resp->wbuf, resp->wbytes); conn_set_state(c, conn_new_cmd); return; error: out_errstring(c, errstr); } static void process_marithmetic_command(conn *c, token_t *tokens, const size_t ntokens) { char *key; size_t nkey; int i; struct _meta_flags of = {0}; // option bitflags. char *errstr = "CLIENT_ERROR bad command line format"; assert(c != NULL); mc_resp *resp = c->resp; // no reservation (like del/set) since we post-process the status line. char *p = resp->wbuf; // If no argument supplied, incr or decr by one. of.delta = 1; of.initial = 0; // redundant, for clarity. bool incr = true; // default mode is to increment. bool locked = false; uint32_t hv = 0; item *it = NULL; // item returned by do_add_delta. WANT_TOKENS_MIN(ntokens, 3); // TODO: most of this is identical to mget. if (tokens[KEY_TOKEN].length > KEY_MAX_LENGTH) { out_string(c, "CLIENT_ERROR bad command line format"); return; } if (ntokens > MFLAG_MAX_OPT_LENGTH) { out_string(c, "CLIENT_ERROR options flags too long"); return; } // scrubs duplicated options and sets flags for how to load the item. // we pass in the first token that should be a flag. if (_meta_flag_preparse(tokens, 2, &of, &errstr) != 0) { out_errstring(c, "CLIENT_ERROR invalid or duplicate flag"); return; } assert(c != NULL); c->noreply = of.no_reply; key = tokens[KEY_TOKEN].value; nkey = tokens[KEY_TOKEN].length; // "mode switch" to alternative commands switch (of.mode) { case 0: // no switch supplied. break; case 'I': // Incr (default) case '+': incr = true; break; case 'D': // Decr. case '-': incr = false; break; default: errstr = "CLIENT_ERROR invalid mode for ma M token"; goto error; break; } // take hash value and manually lock item... hold lock during store phase // on miss and avoid recalculating the hash multiple times. hv = hash(key, nkey); item_lock(hv); locked = true; char tmpbuf[INCR_MAX_STORAGE_LEN]; // return a referenced item if it exists, so we can modify it here, rather // than adding even more parameters to do_add_delta. bool item_created = false; switch(do_add_delta(c->thread, key, nkey, incr, of.delta, tmpbuf, &of.req_cas_id, hv, &it)) { case OK: if (c->noreply) resp->skip = true; // *it was filled, set the status below. break; case NON_NUMERIC: errstr = "CLIENT_ERROR cannot increment or decrement non-numeric value"; goto error; break; case EOM: errstr = "SERVER_ERROR out of memory"; goto error; break; case DELTA_ITEM_NOT_FOUND: if (of.vivify) { itoa_u64(of.initial, tmpbuf); int vlen = strlen(tmpbuf); it = item_alloc(key, nkey, 0, 0, vlen+2); if (it != NULL) { memcpy(ITEM_data(it), tmpbuf, vlen); memcpy(ITEM_data(it) + vlen, "\r\n", 2); if (do_store_item(it, NREAD_ADD, c->thread, hv, NULL, NULL, CAS_NO_STALE)) { item_created = true; } else { // Not sure how we can get here if we're holding the lock. memcpy(resp->wbuf, "NS", 2); } } else { errstr = "SERVER_ERROR Out of memory allocating new item"; goto error; } } else { pthread_mutex_lock(&c->thread->stats.mutex); if (incr) { c->thread->stats.incr_misses++; } else { c->thread->stats.decr_misses++; } pthread_mutex_unlock(&c->thread->stats.mutex); // won't have a valid it here. memcpy(p, "NF", 2); p += 2; } break; case DELTA_ITEM_CAS_MISMATCH: // also returns without a valid it. memcpy(p, "EX", 2); p += 2; break; } // final loop // allows building the response with information after vivifying from a // miss, or returning a new CAS value after add_delta(). if (it) { size_t vlen = strlen(tmpbuf); if (of.value) { memcpy(p, "VA ", 3); p = itoa_u32(vlen, p+3); } else { memcpy(p, "HD", 2); p += 2; } for (i = KEY_TOKEN+1; i < ntokens-1; i++) { switch (tokens[i].value[0]) { case 'c': META_CHAR(p, 'c'); p = itoa_u64(ITEM_get_cas(it), p); break; case 't': META_CHAR(p, 't'); if (it->exptime == 0) { *p = '-'; *(p+1) = '1'; p += 2; } else { p = itoa_u32(it->exptime - current_time, p); } break; case 'T': it->exptime = of.exptime; break; case 'N': if (item_created) { it->exptime = of.autoviv_exptime; } break; // TODO: macro perhaps? case 'O': if (tokens[i].length > MFLAG_MAX_OPAQUE_LENGTH) { errstr = "CLIENT_ERROR opaque token too long"; goto error; } META_SPACE(p); memcpy(p, tokens[i].value, tokens[i].length); p += tokens[i].length; break; case 'k': META_KEY(p, key, nkey, of.key_binary); break; } } if (of.value) { *p = '\r'; *(p+1) = '\n'; p += 2; memcpy(p, tmpbuf, vlen); p += vlen; } do_item_remove(it); } else { // No item to handle. still need to return opaque/key tokens for (i = KEY_TOKEN+1; i < ntokens-1; i++) { switch (tokens[i].value[0]) { // TODO: macro perhaps? case 'O': if (tokens[i].length > MFLAG_MAX_OPAQUE_LENGTH) { errstr = "CLIENT_ERROR opaque token too long"; goto error; } META_SPACE(p); memcpy(p, tokens[i].value, tokens[i].length); p += tokens[i].length; break; case 'k': META_KEY(p, key, nkey, of.key_binary); break; } } } item_unlock(hv); resp->wbytes = p - resp->wbuf; memcpy(resp->wbuf + resp->wbytes, "\r\n", 2); resp->wbytes += 2; resp_add_iov(resp, resp->wbuf, resp->wbytes); conn_set_state(c, conn_new_cmd); return; error: if (it != NULL) do_item_remove(it); if (locked) item_unlock(hv); out_errstring(c, errstr); } static void process_update_command(conn *c, token_t *tokens, const size_t ntokens, int comm, bool handle_cas) { char *key; size_t nkey; unsigned int flags; int32_t exptime_int = 0; rel_time_t exptime = 0; int vlen; uint64_t req_cas_id=0; item *it; assert(c != NULL); set_noreply_maybe(c, tokens, ntokens); if (tokens[KEY_TOKEN].length > KEY_MAX_LENGTH) { out_string(c, "CLIENT_ERROR bad command line format"); return; } key = tokens[KEY_TOKEN].value; nkey = tokens[KEY_TOKEN].length; if (! (safe_strtoul(tokens[2].value, (uint32_t *)&flags) && safe_strtol(tokens[3].value, &exptime_int) && safe_strtol(tokens[4].value, (int32_t *)&vlen))) { out_string(c, "CLIENT_ERROR bad command line format"); return; } exptime = realtime(EXPTIME_TO_POSITIVE_TIME(exptime_int)); // does cas value exist? if (handle_cas) { if (!safe_strtoull(tokens[5].value, &req_cas_id)) { out_string(c, "CLIENT_ERROR bad command line format"); return; } } if (vlen < 0 || vlen > (INT_MAX - 2)) { out_string(c, "CLIENT_ERROR bad command line format"); return; } vlen += 2; if (settings.detail_enabled) { stats_prefix_record_set(key, nkey); } it = item_alloc(key, nkey, flags, exptime, vlen); if (it == 0) { enum store_item_type status; if (! item_size_ok(nkey, flags, vlen)) { out_string(c, "SERVER_ERROR object too large for cache"); status = TOO_LARGE; pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.store_too_large++; pthread_mutex_unlock(&c->thread->stats.mutex); } else { out_of_memory(c, "SERVER_ERROR out of memory storing object"); status = NO_MEMORY; pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.store_no_memory++; pthread_mutex_unlock(&c->thread->stats.mutex); } LOGGER_LOG(c->thread->l, LOG_MUTATIONS, LOGGER_ITEM_STORE, NULL, status, comm, key, nkey, 0, 0, c->sfd); /* swallow the data line */ conn_set_state(c, conn_swallow); c->sbytes = vlen; /* Avoid stale data persisting in cache because we failed alloc. * Unacceptable for SET. Anywhere else too? */ if (comm == NREAD_SET) { it = item_get(key, nkey, c->thread, DONT_UPDATE); if (it) { item_unlink(it); STORAGE_delete(c->thread->storage, it); item_remove(it); } } return; } ITEM_set_cas(it, req_cas_id); c->item = it; #ifdef NEED_ALIGN if (it->it_flags & ITEM_CHUNKED) { c->ritem = ITEM_schunk(it); } else { c->ritem = ITEM_data(it); } #else c->ritem = ITEM_data(it); #endif c->rlbytes = it->nbytes; c->cmd = comm; conn_set_state(c, conn_nread); } static void process_touch_command(conn *c, token_t *tokens, const size_t ntokens) { char *key; size_t nkey; int32_t exptime_int = 0; rel_time_t exptime = 0; item *it; assert(c != NULL); set_noreply_maybe(c, tokens, ntokens); if (tokens[KEY_TOKEN].length > KEY_MAX_LENGTH) { out_string(c, "CLIENT_ERROR bad command line format"); return; } key = tokens[KEY_TOKEN].value; nkey = tokens[KEY_TOKEN].length; if (!safe_strtol(tokens[2].value, &exptime_int)) { out_string(c, "CLIENT_ERROR invalid exptime argument"); return; } exptime = realtime(EXPTIME_TO_POSITIVE_TIME(exptime_int)); it = item_touch(key, nkey, exptime, c->thread); if (it) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.touch_cmds++; c->thread->stats.slab_stats[ITEM_clsid(it)].touch_hits++; pthread_mutex_unlock(&c->thread->stats.mutex); out_string(c, "TOUCHED"); item_remove(it); } else { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.touch_cmds++; c->thread->stats.touch_misses++; pthread_mutex_unlock(&c->thread->stats.mutex); out_string(c, "NOT_FOUND"); } } static void process_arithmetic_command(conn *c, token_t *tokens, const size_t ntokens, const bool incr) { char temp[INCR_MAX_STORAGE_LEN]; uint64_t delta; char *key; size_t nkey; assert(c != NULL); set_noreply_maybe(c, tokens, ntokens); if (tokens[KEY_TOKEN].length > KEY_MAX_LENGTH) { out_string(c, "CLIENT_ERROR bad command line format"); return; } key = tokens[KEY_TOKEN].value; nkey = tokens[KEY_TOKEN].length; if (!safe_strtoull(tokens[2].value, &delta)) { out_string(c, "CLIENT_ERROR invalid numeric delta argument"); return; } switch(add_delta(c->thread, key, nkey, incr, delta, temp, NULL)) { case OK: out_string(c, temp); break; case NON_NUMERIC: out_string(c, "CLIENT_ERROR cannot increment or decrement non-numeric value"); break; case EOM: out_of_memory(c, "SERVER_ERROR out of memory"); break; case DELTA_ITEM_NOT_FOUND: pthread_mutex_lock(&c->thread->stats.mutex); if (incr) { c->thread->stats.incr_misses++; } else { c->thread->stats.decr_misses++; } pthread_mutex_unlock(&c->thread->stats.mutex); out_string(c, "NOT_FOUND"); break; case DELTA_ITEM_CAS_MISMATCH: break; /* Should never get here */ } } static void process_delete_command(conn *c, token_t *tokens, const size_t ntokens) { char *key; size_t nkey; item *it; uint32_t hv; assert(c != NULL); if (ntokens > 3) { bool hold_is_zero = strcmp(tokens[KEY_TOKEN+1].value, "0") == 0; bool sets_noreply = set_noreply_maybe(c, tokens, ntokens); bool valid = (ntokens == 4 && (hold_is_zero || sets_noreply)) || (ntokens == 5 && hold_is_zero && sets_noreply); if (!valid) { out_string(c, "CLIENT_ERROR bad command line format. " "Usage: delete [noreply]"); return; } } key = tokens[KEY_TOKEN].value; nkey = tokens[KEY_TOKEN].length; if(nkey > KEY_MAX_LENGTH) { out_string(c, "CLIENT_ERROR bad command line format"); return; } if (settings.detail_enabled) { stats_prefix_record_delete(key, nkey); } it = item_get_locked(key, nkey, c->thread, DONT_UPDATE, &hv); if (it) { MEMCACHED_COMMAND_DELETE(c->sfd, ITEM_key(it), it->nkey); pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.slab_stats[ITEM_clsid(it)].delete_hits++; pthread_mutex_unlock(&c->thread->stats.mutex); LOGGER_LOG(NULL, LOG_DELETIONS, LOGGER_DELETIONS, it, LOG_TYPE_DELETE); do_item_unlink(it, hv); STORAGE_delete(c->thread->storage, it); do_item_remove(it); /* release our reference */ out_string(c, "DELETED"); } else { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.delete_misses++; pthread_mutex_unlock(&c->thread->stats.mutex); out_string(c, "NOT_FOUND"); } item_unlock(hv); } static void process_verbosity_command(conn *c, token_t *tokens, const size_t ntokens) { unsigned int level; assert(c != NULL); set_noreply_maybe(c, tokens, ntokens); if (!safe_strtoul(tokens[1].value, (uint32_t*)&level)) { out_string(c, "CLIENT_ERROR bad command line format"); return; } settings.verbose = level > MAX_VERBOSITY_LEVEL ? MAX_VERBOSITY_LEVEL : level; out_string(c, "OK"); return; } #ifdef MEMCACHED_DEBUG static void process_misbehave_command(conn *c) { int allowed = 0; // try opening new TCP socket int i = socket(AF_INET, SOCK_STREAM, 0); if (i != -1) { allowed++; close(i); } // try executing new commands i = system("sleep 0"); if (i != -1) { allowed++; } if (allowed) { out_string(c, "ERROR"); } else { out_string(c, "OK"); } } static void process_debugtime_command(conn *c, token_t *tokens, const size_t ntokens) { if (strcmp(tokens[1].value, "p") == 0) { if (!is_paused) { is_paused = true; } } else if (strcmp(tokens[1].value, "r") == 0) { if (is_paused) { is_paused = false; } } else { int64_t time_delta = 0; if (!safe_strtoll(tokens[1].value, &time_delta)) { out_string(c, "ERROR"); return; } delta += time_delta; current_time += delta; } out_string(c, "OK"); } #endif static void process_slabs_automove_command(conn *c, token_t *tokens, const size_t ntokens) { unsigned int level; double ratio; assert(c != NULL); set_noreply_maybe(c, tokens, ntokens); if (strcmp(tokens[2].value, "ratio") == 0) { if (ntokens < 5 || !safe_strtod(tokens[3].value, &ratio)) { out_string(c, "ERROR"); return; } settings.slab_automove_ratio = ratio; } else { if (!safe_strtoul(tokens[2].value, (uint32_t*)&level)) { out_string(c, "CLIENT_ERROR bad command line format"); return; } if (level == 0) { settings.slab_automove = 0; } else if (level == 1 || level == 2) { settings.slab_automove = level; } else { out_string(c, "ERROR"); return; } } out_string(c, "OK"); return; } /* TODO: decide on syntax for sampling? */ static void process_watch_command(conn *c, token_t *tokens, const size_t ntokens) { uint16_t f = 0; int x; assert(c != NULL); set_noreply_maybe(c, tokens, ntokens); if (!settings.watch_enabled) { out_string(c, "CLIENT_ERROR watch commands not allowed"); return; } if (resp_has_stack(c)) { out_string(c, "ERROR cannot pipeline other commands before watch"); return; } if (ntokens > 2) { for (x = COMMAND_TOKEN + 1; x < ntokens - 1; x++) { if ((strcmp(tokens[x].value, "rawcmds") == 0)) { f |= LOG_RAWCMDS; } else if ((strcmp(tokens[x].value, "evictions") == 0)) { f |= LOG_EVICTIONS; } else if ((strcmp(tokens[x].value, "fetchers") == 0)) { f |= LOG_FETCHERS; } else if ((strcmp(tokens[x].value, "mutations") == 0)) { f |= LOG_MUTATIONS; } else if ((strcmp(tokens[x].value, "sysevents") == 0)) { f |= LOG_SYSEVENTS; } else if ((strcmp(tokens[x].value, "connevents") == 0)) { f |= LOG_CONNEVENTS; } else if ((strcmp(tokens[x].value, "proxyreqs") == 0)) { f |= LOG_PROXYREQS; } else if ((strcmp(tokens[x].value, "proxyevents") == 0)) { f |= LOG_PROXYEVENTS; } else if ((strcmp(tokens[x].value, "proxyuser") == 0)) { f |= LOG_PROXYUSER; } else if ((strcmp(tokens[x].value, "deletions") == 0)) { f |= LOG_DELETIONS; } else { out_string(c, "ERROR"); return; } } } else { f |= LOG_FETCHERS; } switch(logger_add_watcher(c, c->sfd, f)) { case LOGGER_ADD_WATCHER_TOO_MANY: out_string(c, "WATCHER_TOO_MANY log watcher limit reached"); break; case LOGGER_ADD_WATCHER_FAILED: out_string(c, "WATCHER_FAILED failed to add log watcher"); break; case LOGGER_ADD_WATCHER_OK: conn_set_state(c, conn_watch); event_del(&c->event); break; } } static void process_memlimit_command(conn *c, token_t *tokens, const size_t ntokens) { uint32_t memlimit; assert(c != NULL); set_noreply_maybe(c, tokens, ntokens); if (!safe_strtoul(tokens[1].value, &memlimit)) { out_string(c, "ERROR"); } else { if (memlimit < 8) { out_string(c, "MEMLIMIT_TOO_SMALL cannot set maxbytes to less than 8m"); } else { if (memlimit > 1000000000) { out_string(c, "MEMLIMIT_ADJUST_FAILED input value is megabytes not bytes"); } else if (slabs_adjust_mem_limit((size_t) memlimit * 1024 * 1024)) { if (settings.verbose > 0) { fprintf(stderr, "maxbytes adjusted to %llum\n", (unsigned long long)memlimit); } out_string(c, "OK"); } else { out_string(c, "MEMLIMIT_ADJUST_FAILED out of bounds or unable to adjust"); } } } } static void process_lru_command(conn *c, token_t *tokens, const size_t ntokens) { uint32_t pct_hot; uint32_t pct_warm; double hot_factor; int32_t ttl; double factor; set_noreply_maybe(c, tokens, ntokens); if (strcmp(tokens[1].value, "tune") == 0 && ntokens >= 7) { if (!safe_strtoul(tokens[2].value, &pct_hot) || !safe_strtoul(tokens[3].value, &pct_warm) || !safe_strtod(tokens[4].value, &hot_factor) || !safe_strtod(tokens[5].value, &factor)) { out_string(c, "ERROR"); } else { if (pct_hot + pct_warm > 80) { out_string(c, "ERROR hot and warm pcts must not exceed 80"); } else if (factor <= 0 || hot_factor <= 0) { out_string(c, "ERROR hot/warm age factors must be greater than 0"); } else { settings.hot_lru_pct = pct_hot; settings.warm_lru_pct = pct_warm; settings.hot_max_factor = hot_factor; settings.warm_max_factor = factor; out_string(c, "OK"); } } } else if (strcmp(tokens[1].value, "mode") == 0 && ntokens >= 4 && settings.lru_maintainer_thread) { if (strcmp(tokens[2].value, "flat") == 0) { settings.lru_segmented = false; out_string(c, "OK"); } else if (strcmp(tokens[2].value, "segmented") == 0) { settings.lru_segmented = true; out_string(c, "OK"); } else { out_string(c, "ERROR"); } } else if (strcmp(tokens[1].value, "temp_ttl") == 0 && ntokens >= 4 && settings.lru_maintainer_thread) { if (!safe_strtol(tokens[2].value, &ttl)) { out_string(c, "ERROR"); } else { if (ttl < 0) { settings.temp_lru = false; } else { settings.temp_lru = true; settings.temporary_ttl = ttl; } out_string(c, "OK"); } } else { out_string(c, "ERROR"); } } #ifdef EXTSTORE static void process_extstore_command(conn *c, token_t *tokens, const size_t ntokens) { set_noreply_maybe(c, tokens, ntokens); bool ok = true; if (ntokens < 4) { ok = false; } else if (strcmp(tokens[1].value, "free_memchunks") == 0 && ntokens > 4) { // setting is deprecated and ignored, but accepted for backcompat unsigned int clsid = 0; unsigned int limit = 0; if (!safe_strtoul(tokens[2].value, &clsid) || !safe_strtoul(tokens[3].value, &limit)) { ok = false; } else { if (clsid < MAX_NUMBER_OF_SLAB_CLASSES) { ok = true; } else { ok = false; } } } else if (strcmp(tokens[1].value, "item_size") == 0) { if (!safe_strtoul(tokens[2].value, &settings.ext_item_size)) ok = false; } else if (strcmp(tokens[1].value, "item_age") == 0) { if (!safe_strtoul(tokens[2].value, &settings.ext_item_age)) ok = false; } else if (strcmp(tokens[1].value, "low_ttl") == 0) { if (!safe_strtoul(tokens[2].value, &settings.ext_low_ttl)) ok = false; } else if (strcmp(tokens[1].value, "recache_rate") == 0) { if (!safe_strtoul(tokens[2].value, &settings.ext_recache_rate)) ok = false; } else if (strcmp(tokens[1].value, "compact_under") == 0) { if (!safe_strtoul(tokens[2].value, &settings.ext_compact_under)) ok = false; } else if (strcmp(tokens[1].value, "drop_under") == 0) { if (!safe_strtoul(tokens[2].value, &settings.ext_drop_under)) ok = false; } else if (strcmp(tokens[1].value, "max_sleep") == 0) { if (!safe_strtoul(tokens[2].value, &settings.ext_max_sleep)) ok = false; } else if (strcmp(tokens[1].value, "max_frag") == 0) { if (!safe_strtod(tokens[2].value, &settings.ext_max_frag)) ok = false; } else if (strcmp(tokens[1].value, "drop_unread") == 0) { unsigned int v; if (!safe_strtoul(tokens[2].value, &v)) { ok = false; } else { settings.ext_drop_unread = v == 0 ? false : true; } } else { ok = false; } if (!ok) { out_string(c, "ERROR"); } else { out_string(c, "OK"); } } #endif static void process_flush_all_command(conn *c, token_t *tokens, const size_t ntokens) { int32_t exptime = 0; rel_time_t new_oldest = 0; set_noreply_maybe(c, tokens, ntokens); pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.flush_cmds++; pthread_mutex_unlock(&c->thread->stats.mutex); if (!settings.flush_enabled) { // flush_all is not allowed but we log it on stats out_string(c, "CLIENT_ERROR flush_all not allowed"); return; } if (ntokens != (c->noreply ? 3 : 2)) { if (!safe_strtol(tokens[1].value, &exptime)) { out_string(c, "CLIENT_ERROR invalid exptime argument"); return; } } /* If exptime is zero realtime() would return zero too, and realtime(exptime) - 1 would overflow to the max unsigned value. So we process exptime == 0 the same way we do when no delay is given at all. */ if (exptime > 0) { new_oldest = realtime(exptime); } else { /* exptime == 0 */ new_oldest = current_time; } if (settings.use_cas) { settings.oldest_live = new_oldest - 1; if (settings.oldest_live <= current_time) settings.oldest_cas = get_cas_id(); } else { settings.oldest_live = new_oldest; } out_string(c, "OK"); } static void process_version_command(conn *c) { out_string(c, "VERSION " VERSION); } static void process_quit_command(conn *c) { conn_set_state(c, conn_mwrite); c->close_after_write = true; c->close_reason = NORMAL_CLOSE; } static void process_shutdown_command(conn *c, token_t *tokens, const size_t ntokens) { if (!settings.shutdown_command) { out_string(c, "ERROR: shutdown not enabled"); return; } if (ntokens == 2) { c->close_reason = SHUTDOWN_CLOSE; conn_set_state(c, conn_closing); raise(SIGINT); } else if (ntokens == 3 && strcmp(tokens[SUBCOMMAND_TOKEN].value, "graceful") == 0) { c->close_reason = SHUTDOWN_CLOSE; conn_set_state(c, conn_closing); raise(SIGUSR1); } else { out_string(c, "CLIENT_ERROR invalid shutdown mode"); } } static void process_slabs_command(conn *c, token_t *tokens, const size_t ntokens) { if (ntokens == 5 && strcmp(tokens[COMMAND_TOKEN + 1].value, "reassign") == 0) { int src, dst, rv; if (settings.slab_reassign == false) { out_string(c, "CLIENT_ERROR slab reassignment disabled"); return; } if (! (safe_strtol(tokens[2].value, (int32_t*)&src) && safe_strtol(tokens[3].value, (int32_t*)&dst))) { out_string(c, "CLIENT_ERROR bad command line format"); return; } rv = slabs_reassign(src, dst); switch (rv) { case REASSIGN_OK: out_string(c, "OK"); break; case REASSIGN_RUNNING: out_string(c, "BUSY currently processing reassign request"); break; case REASSIGN_BADCLASS: out_string(c, "BADCLASS invalid src or dst class id"); break; case REASSIGN_NOSPARE: out_string(c, "NOSPARE source class has no spare pages"); break; case REASSIGN_SRC_DST_SAME: out_string(c, "SAME src and dst class are identical"); break; } return; } else if (ntokens >= 4 && (strcmp(tokens[COMMAND_TOKEN + 1].value, "automove") == 0)) { process_slabs_automove_command(c, tokens, ntokens); } else { out_string(c, "ERROR"); } } static void process_lru_crawler_command(conn *c, token_t *tokens, const size_t ntokens) { if (ntokens == 4 && strcmp(tokens[COMMAND_TOKEN + 1].value, "crawl") == 0) { int rv; if (settings.lru_crawler == false) { out_string(c, "CLIENT_ERROR lru crawler disabled"); return; } rv = lru_crawler_crawl(tokens[2].value, CRAWLER_EXPIRED, NULL, 0, settings.lru_crawler_tocrawl); switch(rv) { case CRAWLER_OK: out_string(c, "OK"); break; case CRAWLER_RUNNING: out_string(c, "BUSY currently processing crawler request"); break; case CRAWLER_BADCLASS: out_string(c, "BADCLASS invalid class id"); break; case CRAWLER_NOTSTARTED: out_string(c, "NOTSTARTED no items to crawl"); break; case CRAWLER_ERROR: out_string(c, "ERROR an unknown error happened"); break; } return; } else if (ntokens == 4 && strcmp(tokens[COMMAND_TOKEN + 1].value, "metadump") == 0) { if (settings.lru_crawler == false) { out_string(c, "CLIENT_ERROR lru crawler disabled"); return; } if (!settings.dump_enabled) { out_string(c, "ERROR metadump not allowed"); return; } if (resp_has_stack(c)) { out_string(c, "ERROR cannot pipeline other commands before metadump"); return; } int rv = lru_crawler_crawl(tokens[2].value, CRAWLER_METADUMP, c, c->sfd, LRU_CRAWLER_CAP_REMAINING); switch(rv) { case CRAWLER_OK: // TODO: documentation says this string is returned, but // it never was before. We never switch to conn_write so // this o_s call never worked. Need to talk to users and // decide if removing the OK from docs is fine. //out_string(c, "OK"); // TODO: Don't reuse conn_watch here. conn_set_state(c, conn_watch); event_del(&c->event); break; case CRAWLER_RUNNING: out_string(c, "BUSY currently processing crawler request"); break; case CRAWLER_BADCLASS: out_string(c, "BADCLASS invalid class id"); break; case CRAWLER_NOTSTARTED: out_string(c, "NOTSTARTED no items to crawl"); break; case CRAWLER_ERROR: out_string(c, "ERROR an unknown error happened"); break; } return; } else if (ntokens == 4 && strcmp(tokens[COMMAND_TOKEN + 1].value, "mgdump") == 0) { if (settings.lru_crawler == false) { out_string(c, "CLIENT_ERROR lru crawler disabled"); return; } if (!settings.dump_enabled) { out_string(c, "ERROR key dump not allowed"); return; } if (resp_has_stack(c)) { out_string(c, "ERROR cannot pipeline other commands before mgdump"); return; } int rv = lru_crawler_crawl(tokens[2].value, CRAWLER_MGDUMP, c, c->sfd, LRU_CRAWLER_CAP_REMAINING); switch(rv) { case CRAWLER_OK: conn_set_state(c, conn_watch); event_del(&c->event); break; case CRAWLER_RUNNING: out_string(c, "BUSY currently processing crawler request"); break; case CRAWLER_BADCLASS: out_string(c, "BADCLASS invalid class id"); break; case CRAWLER_NOTSTARTED: out_string(c, "NOTSTARTED no items to crawl"); break; case CRAWLER_ERROR: out_string(c, "ERROR an unknown error happened"); break; } return; } else if (ntokens == 4 && strcmp(tokens[COMMAND_TOKEN + 1].value, "tocrawl") == 0) { uint32_t tocrawl; if (!safe_strtoul(tokens[2].value, &tocrawl)) { out_string(c, "CLIENT_ERROR bad command line format"); return; } settings.lru_crawler_tocrawl = tocrawl; out_string(c, "OK"); return; } else if (ntokens == 4 && strcmp(tokens[COMMAND_TOKEN + 1].value, "sleep") == 0) { uint32_t tosleep; if (!safe_strtoul(tokens[2].value, &tosleep)) { out_string(c, "CLIENT_ERROR bad command line format"); return; } if (tosleep > 1000000) { out_string(c, "CLIENT_ERROR sleep must be one second or less"); return; } settings.lru_crawler_sleep = tosleep; out_string(c, "OK"); return; } else if (ntokens == 3) { if ((strcmp(tokens[COMMAND_TOKEN + 1].value, "enable") == 0)) { if (start_item_crawler_thread() == 0) { out_string(c, "OK"); } else { out_string(c, "ERROR failed to start lru crawler thread"); } } else if ((strcmp(tokens[COMMAND_TOKEN + 1].value, "disable") == 0)) { if (stop_item_crawler_thread(CRAWLER_NOWAIT) == 0) { out_string(c, "OK"); } else { out_string(c, "ERROR failed to stop lru crawler thread"); } } else { out_string(c, "ERROR"); } return; } else { out_string(c, "ERROR"); } } #ifdef TLS static void process_refresh_certs_command(conn *c, token_t *tokens, const size_t ntokens) { set_noreply_maybe(c, tokens, ntokens); char *errmsg = NULL; if (refresh_certs(&errmsg)) { out_string(c, "OK"); } else { write_and_free(c, errmsg, strlen(errmsg)); } return; } #endif // TODO: pipelined commands are incompatible with shifting connections to a // side thread. Given this only happens in two instances (watch and // lru_crawler metadump) it should be fine for things to bail. It _should_ be // unusual for these commands. // This is hard to fix since tokenize_command() mutilates the read buffer, so // we can't drop out and back in again. // Leaving this note here to spend more time on a fix when necessary, or if an // opportunity becomes obvious. void process_command_ascii(conn *c, char *command) { token_t tokens[MAX_TOKENS]; size_t ntokens; int comm; assert(c != NULL); MEMCACHED_PROCESS_COMMAND_START(c->sfd, c->rcurr, c->rbytes); if (settings.verbose > 1) fprintf(stderr, "<%d %s\n", c->sfd, command); /* * for commands set/add/replace, we build an item and read the data * directly into it, then continue in nread_complete(). */ // Prep the response object for this query. if (!resp_start(c)) { conn_set_state(c, conn_closing); return; } c->thread->cur_sfd = c->sfd; // cuddle sfd for logging. ntokens = tokenize_command(command, tokens, MAX_TOKENS); // All commands need a minimum of two tokens: cmd and NULL finalizer // There are also no valid commands shorter than two bytes. if (ntokens < 2 || tokens[COMMAND_TOKEN].length < 2) { out_string(c, "ERROR"); return; } // Meta commands are all 2-char in length. char first = tokens[COMMAND_TOKEN].value[0]; if (first == 'm' && tokens[COMMAND_TOKEN].length == 2) { switch (tokens[COMMAND_TOKEN].value[1]) { case 'g': process_mget_command(c, tokens, ntokens); break; case 's': process_mset_command(c, tokens, ntokens); break; case 'd': process_mdelete_command(c, tokens, ntokens); break; case 'n': out_string(c, "MN"); // mn command forces immediate writeback flush. conn_set_state(c, conn_mwrite); break; case 'a': process_marithmetic_command(c, tokens, ntokens); break; case 'e': process_meta_command(c, tokens, ntokens); break; default: out_string(c, "ERROR"); break; } } else if (first == 'g') { // Various get commands are very common. WANT_TOKENS_MIN(ntokens, 3); if (strcmp(tokens[COMMAND_TOKEN].value, "get") == 0) { process_get_command(c, tokens, ntokens, false, false); } else if (strcmp(tokens[COMMAND_TOKEN].value, "gets") == 0) { process_get_command(c, tokens, ntokens, true, false); } else if (strcmp(tokens[COMMAND_TOKEN].value, "gat") == 0) { process_get_command(c, tokens, ntokens, false, true); } else if (strcmp(tokens[COMMAND_TOKEN].value, "gats") == 0) { process_get_command(c, tokens, ntokens, true, true); } else { out_string(c, "ERROR"); } } else if (first == 's') { if (strcmp(tokens[COMMAND_TOKEN].value, "set") == 0 && (comm = NREAD_SET)) { WANT_TOKENS_OR(ntokens, 6, 7); process_update_command(c, tokens, ntokens, comm, false); } else if (strcmp(tokens[COMMAND_TOKEN].value, "stats") == 0) { process_stat(c, tokens, ntokens); } else if (strcmp(tokens[COMMAND_TOKEN].value, "shutdown") == 0) { process_shutdown_command(c, tokens, ntokens); } else if (strcmp(tokens[COMMAND_TOKEN].value, "slabs") == 0) { process_slabs_command(c, tokens, ntokens); } else { out_string(c, "ERROR"); } } else if (first == 'a') { if ((strcmp(tokens[COMMAND_TOKEN].value, "add") == 0 && (comm = NREAD_ADD)) || (strcmp(tokens[COMMAND_TOKEN].value, "append") == 0 && (comm = NREAD_APPEND)) ) { WANT_TOKENS_OR(ntokens, 6, 7); process_update_command(c, tokens, ntokens, comm, false); } else { out_string(c, "ERROR"); } } else if (first == 'c') { if (strcmp(tokens[COMMAND_TOKEN].value, "cas") == 0 && (comm = NREAD_CAS)) { WANT_TOKENS_OR(ntokens, 7, 8); process_update_command(c, tokens, ntokens, comm, true); } else if (strcmp(tokens[COMMAND_TOKEN].value, "cache_memlimit") == 0) { WANT_TOKENS_OR(ntokens, 3, 4); process_memlimit_command(c, tokens, ntokens); } else { out_string(c, "ERROR"); } } else if (first == 'i') { if (strcmp(tokens[COMMAND_TOKEN].value, "incr") == 0) { WANT_TOKENS_OR(ntokens, 4, 5); process_arithmetic_command(c, tokens, ntokens, 1); } else { out_string(c, "ERROR"); } } else if (first == 'd') { if (strcmp(tokens[COMMAND_TOKEN].value, "delete") == 0) { WANT_TOKENS(ntokens, 3, 5); process_delete_command(c, tokens, ntokens); } else if (strcmp(tokens[COMMAND_TOKEN].value, "decr") == 0) { WANT_TOKENS_OR(ntokens, 4, 5); process_arithmetic_command(c, tokens, ntokens, 0); #ifdef MEMCACHED_DEBUG } else if (strcmp(tokens[COMMAND_TOKEN].value, "debugtime") == 0) { WANT_TOKENS_MIN(ntokens, 2); process_debugtime_command(c, tokens, ntokens); #endif } else { out_string(c, "ERROR"); } } else if (first == 't') { if (strcmp(tokens[COMMAND_TOKEN].value, "touch") == 0) { WANT_TOKENS_OR(ntokens, 4, 5); process_touch_command(c, tokens, ntokens); } else { out_string(c, "ERROR"); } } else if ( (strcmp(tokens[COMMAND_TOKEN].value, "replace") == 0 && (comm = NREAD_REPLACE)) || (strcmp(tokens[COMMAND_TOKEN].value, "prepend") == 0 && (comm = NREAD_PREPEND)) ) { WANT_TOKENS_OR(ntokens, 6, 7); process_update_command(c, tokens, ntokens, comm, false); } else if (strcmp(tokens[COMMAND_TOKEN].value, "bget") == 0) { // ancient "binary get" command which isn't in any documentation, was // removed > 10 years ago, etc. Keeping for compatibility reasons but // we should look deeper into client code and remove this. WANT_TOKENS_MIN(ntokens, 3); process_get_command(c, tokens, ntokens, false, false); } else if (strcmp(tokens[COMMAND_TOKEN].value, "flush_all") == 0) { WANT_TOKENS(ntokens, 2, 4); process_flush_all_command(c, tokens, ntokens); } else if (strcmp(tokens[COMMAND_TOKEN].value, "version") == 0) { process_version_command(c); } else if (strcmp(tokens[COMMAND_TOKEN].value, "quit") == 0) { process_quit_command(c); } else if (strcmp(tokens[COMMAND_TOKEN].value, "lru_crawler") == 0) { process_lru_crawler_command(c, tokens, ntokens); } else if (strcmp(tokens[COMMAND_TOKEN].value, "watch") == 0) { process_watch_command(c, tokens, ntokens); } else if (strcmp(tokens[COMMAND_TOKEN].value, "verbosity") == 0) { WANT_TOKENS_OR(ntokens, 3, 4); process_verbosity_command(c, tokens, ntokens); } else if (strcmp(tokens[COMMAND_TOKEN].value, "lru") == 0) { WANT_TOKENS_MIN(ntokens, 3); process_lru_command(c, tokens, ntokens); #ifdef MEMCACHED_DEBUG // commands which exist only for testing the memcached's security protection } else if (strcmp(tokens[COMMAND_TOKEN].value, "misbehave") == 0) { process_misbehave_command(c); #endif #ifdef EXTSTORE } else if (strcmp(tokens[COMMAND_TOKEN].value, "extstore") == 0) { WANT_TOKENS_MIN(ntokens, 3); process_extstore_command(c, tokens, ntokens); #endif #ifdef TLS } else if (strcmp(tokens[COMMAND_TOKEN].value, "refresh_certs") == 0) { process_refresh_certs_command(c, tokens, ntokens); #endif } else { if (strncmp(tokens[ntokens - 2].value, "HTTP/", 5) == 0) { conn_set_state(c, conn_closing); } else { out_string(c, "ERROR"); } } return; } memcached-1.6.20/logger.c0000664000175000017500000011216014427543277012074 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include #include #include #include #include #include #include #include #if defined(__sun) #include #endif #include "memcached.h" #include "bipbuffer.h" #ifdef LOGGER_DEBUG #define L_DEBUG(...) \ do { \ fprintf(stderr, __VA_ARGS__); \ } while (0) #else #define L_DEBUG(...) #endif /* TODO: put this in a struct and ditch the global vars. */ static logger *logger_stack_head = NULL; static logger *logger_stack_tail = NULL; static unsigned int logger_count = 0; static volatile int do_run_logger_thread = 1; static pthread_t logger_tid; pthread_mutex_t logger_stack_lock = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t logger_stack_cond = PTHREAD_COND_INITIALIZER; pthread_key_t logger_key; #if !defined(HAVE_GCC_64ATOMICS) && !defined(__sun) pthread_mutex_t logger_atomics_mutex = PTHREAD_MUTEX_INITIALIZER; #endif #define WATCHER_LIMIT 20 logger_watcher *watchers[20]; struct pollfd watchers_pollfds[20]; int watcher_count = 0; #define WATCHER_ALL -1 static int logger_thread_poll_watchers(int force_poll, int watcher); /* helpers for logger_log */ static void _logger_log_text(logentry *e, const entry_details *d, const void *entry, va_list ap) { int reqlen = d->reqlen; int total = vsnprintf((char *) e->data, reqlen, d->format, ap); if (total <= 0) { fprintf(stderr, "LOGGER: Failed to vsnprintf a text entry: (total) %d\n", total); } e->size = total + 1; // null byte } static void _logger_log_evictions(logentry *e, const entry_details *d, const void *entry, va_list ap) { item *it = (item *)entry; struct logentry_eviction *le = (struct logentry_eviction *) e->data; le->exptime = (it->exptime > 0) ? (long long int)(it->exptime - current_time) : (long long int) -1; le->latime = current_time - it->time; le->it_flags = it->it_flags; le->nkey = it->nkey; le->nbytes = it->nbytes; le->clsid = ITEM_clsid(it); memcpy(le->key, ITEM_key(it), it->nkey); e->size = sizeof(struct logentry_eviction) + le->nkey; } #ifdef EXTSTORE static void _logger_log_ext_write(logentry *e, const entry_details *d, const void *entry, va_list ap) { item *it = (item *)entry; int ew_bucket = va_arg(ap, int); struct logentry_ext_write *le = (struct logentry_ext_write *) e->data; le->exptime = (it->exptime > 0) ? (long long int)(it->exptime - current_time) : (long long int) -1; le->latime = current_time - it->time; le->it_flags = it->it_flags; le->nkey = it->nkey; le->clsid = ITEM_clsid(it); le->bucket = (uint8_t)ew_bucket; memcpy(le->key, ITEM_key(it), it->nkey); e->size = sizeof(struct logentry_ext_write) + le->nkey; } #endif // 0 == nf, 1 == found. 2 == flushed. 3 == expired. // might be useful to store/print the flags an item has? // could also collapse this and above code into an "item status" struct. wait // for more endpoints to be written before making it generic, though. static void _logger_log_item_get(logentry *e, const entry_details *d, const void *entry, va_list ap) { int was_found = va_arg(ap, int); char *key = va_arg(ap, char *); int nkey = va_arg(ap, int); int nbytes = va_arg(ap, int); uint8_t clsid = va_arg(ap, int); int sfd = va_arg(ap, int); struct logentry_item_get *le = (struct logentry_item_get *) e->data; le->was_found = was_found; le->nkey = nkey; le->nbytes = nbytes; le->clsid = clsid; memcpy(le->key, key, nkey); le->sfd = sfd; e->size = sizeof(struct logentry_item_get) + nkey; } static void _logger_log_item_store(logentry *e, const entry_details *d, const void *entry, va_list ap) { enum store_item_type status = va_arg(ap, enum store_item_type); int comm = va_arg(ap, int); char *key = va_arg(ap, char *); int nkey = va_arg(ap, int); int nbytes = va_arg(ap, int); rel_time_t ttl = va_arg(ap, rel_time_t); uint8_t clsid = va_arg(ap, int); int sfd = va_arg(ap, int); struct logentry_item_store *le = (struct logentry_item_store *) e->data; le->status = status; le->cmd = comm; le->nkey = nkey; le->nbytes = nbytes; le->clsid = clsid; if (ttl != 0) { le->ttl = ttl - current_time; } else { le->ttl = 0; } memcpy(le->key, key, nkey); le->sfd = sfd; e->size = sizeof(struct logentry_item_store) + nkey; } static void _logger_log_item_deleted(logentry *e, const entry_details *d, const void *entry, va_list ap) { item *it = (item *)entry; int comm = va_arg(ap, int); struct logentry_deletion *le = (struct logentry_deletion *) e->data; le->nkey = it->nkey; le->cmd = comm; le->nbytes = it->nbytes; le->clsid = ITEM_clsid(it); memcpy(le->key, ITEM_key(it), it->nkey); e->size = sizeof(struct logentry_deletion) + le->nkey; } static void _logger_log_conn_event(logentry *e, const entry_details *d, const void *entry, va_list ap) { struct sockaddr_in6 *addr = va_arg(ap, struct sockaddr_in6 *); socklen_t addrlen = va_arg(ap, socklen_t); enum network_transport transport = va_arg(ap, enum network_transport); enum close_reasons reason = va_arg(ap, enum close_reasons); int sfd = va_arg(ap, int); struct logentry_conn_event *le = (struct logentry_conn_event *) e->data; memcpy(&le->addr, addr, addrlen); le->sfd = sfd; le->transport = transport; le->reason = reason; e->size = sizeof(struct logentry_conn_event); } /************************* * Util functions used by the logger background thread *************************/ static int _logger_util_addr_endpoint(struct sockaddr_in6 *addr, char *rip, size_t riplen, unsigned short *rport) { memset(rip, 0, riplen); *rport = 0; switch (addr->sin6_family) { case AF_INET: inet_ntop(AF_INET, &((struct sockaddr_in *) addr)->sin_addr, rip, riplen - 1); *rport = ntohs(((struct sockaddr_in *) addr)->sin_port); break; case AF_INET6: inet_ntop(AF_INET6, &((struct sockaddr_in6 *) addr)->sin6_addr, rip, riplen - 1); *rport = ntohs(((struct sockaddr_in6 *) addr)->sin6_port); break; #ifndef DISABLE_UNIX_SOCKET // Connections on Unix socket transports have c->request_addr zeroed out. case AF_UNSPEC: case AF_UNIX: strncpy(rip, "unix", strlen("unix") + 1); break; #endif // #ifndef DISABLE_UNIX_SOCKET } return 0; } /************************* * Logger background thread functions. Aggregates per-worker buffers and * writes to any watchers. *************************/ #define LOGGER_PARSE_SCRATCH 4096 static int _logger_parse_text(logentry *e, char *scratch) { return snprintf(scratch, LOGGER_PARSE_SCRATCH, "ts=%lld.%d gid=%llu %s\n", (long long int)e->tv.tv_sec, (int)e->tv.tv_usec, (unsigned long long) e->gid, (char *) e->data); } static int _logger_parse_ise(logentry *e, char *scratch) { int total; const char *cmd = "na"; char keybuf[KEY_MAX_URI_ENCODED_LENGTH]; struct logentry_item_store *le = (struct logentry_item_store *) e->data; const char * const status_map[] = { "not_stored", "stored", "exists", "not_found", "too_large", "no_memory" }; const char * const cmd_map[] = { "null", "add", "set", "replace", "append", "prepend", "cas", "append", "prepend" }; if (le->cmd <= 8) cmd = cmd_map[le->cmd]; uriencode(le->key, keybuf, le->nkey, KEY_MAX_URI_ENCODED_LENGTH); total = snprintf(scratch, LOGGER_PARSE_SCRATCH, "ts=%lld.%d gid=%llu type=item_store key=%s status=%s cmd=%s ttl=%u clsid=%u cfd=%d size=%d\n", (long long int)e->tv.tv_sec, (int)e->tv.tv_usec, (unsigned long long) e->gid, keybuf, status_map[le->status], cmd, le->ttl, le->clsid, le->sfd, le->nbytes > 0 ? le->nbytes - 2 : 0); // CLRF return total; } static int _logger_parse_ige(logentry *e, char *scratch) { int total; struct logentry_item_get *le = (struct logentry_item_get *) e->data; char keybuf[KEY_MAX_URI_ENCODED_LENGTH]; const char * const was_found_map[] = { "not_found", "found", "flushed", "expired" }; uriencode(le->key, keybuf, le->nkey, KEY_MAX_URI_ENCODED_LENGTH); total = snprintf(scratch, LOGGER_PARSE_SCRATCH, "ts=%lld.%d gid=%llu type=item_get key=%s status=%s clsid=%u cfd=%d size=%d\n", (long long int)e->tv.tv_sec, (int)e->tv.tv_usec, (unsigned long long) e->gid, keybuf, was_found_map[le->was_found], le->clsid, le->sfd, le->nbytes > 0 ? le->nbytes - 2 : 0); // CLRF return total; } static int _logger_parse_ee(logentry *e, char *scratch) { int total; char keybuf[KEY_MAX_URI_ENCODED_LENGTH]; struct logentry_eviction *le = (struct logentry_eviction *) e->data; uriencode(le->key, keybuf, le->nkey, KEY_MAX_URI_ENCODED_LENGTH); total = snprintf(scratch, LOGGER_PARSE_SCRATCH, "ts=%lld.%d gid=%llu type=eviction key=%s fetch=%s ttl=%lld la=%d clsid=%u size=%d\n", (long long int)e->tv.tv_sec, (int)e->tv.tv_usec, (unsigned long long) e->gid, keybuf, (le->it_flags & ITEM_FETCHED) ? "yes" : "no", (long long int)le->exptime, le->latime, le->clsid, le->nbytes > 0 ? le->nbytes - 2 : 0); // CLRF return total; } static int _logger_parse_ide(logentry *e, char *scratch) { int total; const char *cmd = "na"; const char * const cmd_map[] = { "null", "delete", "md" }; char keybuf[KEY_MAX_URI_ENCODED_LENGTH]; struct logentry_deletion *le = (struct logentry_deletion *) e->data; uriencode(le->key, keybuf, le->nkey, KEY_MAX_URI_ENCODED_LENGTH); if (le->cmd <= 2) cmd = cmd_map[le->cmd]; total = snprintf(scratch, LOGGER_PARSE_SCRATCH, "ts=%d.%d gid=%llu type=deleted key=%s cmd=%s clsid=%u size=%d\n", (int)e->tv.tv_sec, (int)e->tv.tv_usec, (unsigned long long) e->gid, keybuf, cmd, le->clsid, le->nbytes > 0 ? le->nbytes - 2 : 0); // CLRF return total; } #ifdef EXTSTORE static int _logger_parse_extw(logentry *e, char *scratch) { int total; char keybuf[KEY_MAX_URI_ENCODED_LENGTH]; struct logentry_ext_write *le = (struct logentry_ext_write *) e->data; uriencode(le->key, keybuf, le->nkey, KEY_MAX_URI_ENCODED_LENGTH); total = snprintf(scratch, LOGGER_PARSE_SCRATCH, "ts=%lld.%d gid=%llu type=extwrite key=%s fetch=%s ttl=%lld la=%d clsid=%u bucket=%u\n", (long long int)e->tv.tv_sec, (int)e->tv.tv_usec, (unsigned long long) e->gid, keybuf, (le->it_flags & ITEM_FETCHED) ? "yes" : "no", (long long int)le->exptime, le->latime, le->clsid, le->bucket); return total; } #endif static int _logger_parse_cne(logentry *e, char *scratch) { int total; unsigned short rport; char rip[64]; struct logentry_conn_event *le = (struct logentry_conn_event *) e->data; const char * const transport_map[] = { "local", "tcp", "udp" }; _logger_util_addr_endpoint(&le->addr, rip, sizeof(rip), &rport); total = snprintf(scratch, LOGGER_PARSE_SCRATCH, "ts=%lld.%d gid=%llu type=conn_new rip=%s rport=%hu transport=%s cfd=%d\n", (long long int) e->tv.tv_sec, (int) e->tv.tv_usec, (unsigned long long) e->gid, rip, rport, transport_map[le->transport], le->sfd); return total; } static int _logger_parse_cce(logentry *e, char *scratch) { int total; unsigned short rport; char rip[64]; struct logentry_conn_event *le = (struct logentry_conn_event *) e->data; const char * const transport_map[] = { "local", "tcp", "udp" }; const char * const reason_map[] = { "error", "normal", "idle_timeout", "shutdown" }; _logger_util_addr_endpoint(&le->addr, rip, sizeof(rip), &rport); total = snprintf(scratch, LOGGER_PARSE_SCRATCH, "ts=%lld.%d gid=%llu type=conn_close rip=%s rport=%hu transport=%s reason=%s cfd=%d\n", (long long int) e->tv.tv_sec, (int) e->tv.tv_usec, (unsigned long long) e->gid, rip, rport, transport_map[le->transport], reason_map[le->reason], le->sfd); return total; } #ifdef PROXY // TODO (v2): the length caps here are all magic numbers. Haven't thought of // something yet that I like better. // Should at least make a define to the max log len (1024) and do some math // here. static void _logger_log_proxy_req(logentry *e, const entry_details *d, const void *entry, va_list ap) { char *req = va_arg(ap, char *); int reqlen = va_arg(ap, uint32_t); long elapsed = va_arg(ap, long); unsigned short type = va_arg(ap, int); unsigned short code = va_arg(ap, int); int status = va_arg(ap, int); char *detail = va_arg(ap, char *); int dlen = va_arg(ap, int); char *be_name = va_arg(ap, char *); char *be_port = va_arg(ap, char *); struct logentry_proxy_req *le = (void *)e->data; le->type = type; le->code = code; le->status = status; le->dlen = dlen; le->elapsed = elapsed; if (be_name && be_port) { le->be_namelen = strlen(be_name); le->be_portlen = strlen(be_port); } else { le->be_namelen = 0; le->be_portlen = 0; } char *data = le->data; if (req[reqlen-2] == '\r') { reqlen -= 2; } else { reqlen--; } if (reqlen > 300) { reqlen = 300; } if (dlen > 150) { dlen = 150; } // be_namelen and be_portlen can't be longer than 255+6 le->reqlen = reqlen; memcpy(data, req, reqlen); data += reqlen; memcpy(data, detail, dlen); data += dlen; memcpy(data, be_name, le->be_namelen); data += le->be_namelen; memcpy(data, be_port, le->be_portlen); e->size = sizeof(struct logentry_proxy_req) + reqlen + dlen + le->be_namelen + le->be_portlen; } static int _logger_parse_prx_req(logentry *e, char *scratch) { int total; struct logentry_proxy_req *le = (void *)e->data; total = snprintf(scratch, LOGGER_PARSE_SCRATCH, "ts=%lld.%d gid=%llu type=proxy_req elapsed=%lu type=%d code=%d status=%d be=%.*s:%.*s detail=%.*s req=%.*s\n", (long long int) e->tv.tv_sec, (int) e->tv.tv_usec, (unsigned long long) e->gid, le->elapsed, le->type, le->code, le->status, (int)le->be_namelen, le->data+le->reqlen+le->dlen, (int)le->be_portlen, le->data+le->reqlen+le->dlen+le->be_namelen, // fml. (int)le->dlen, le->data+le->reqlen, (int)le->reqlen, le->data ); return total; } #define MAX_RBUF_READ 100 static void _logger_log_proxy_errbe(logentry *e, const entry_details *d, const void *entry, va_list ap) { char *errmsg = va_arg(ap, char *); char *be_name = va_arg(ap, char *); char *be_port = va_arg(ap, char *); int be_depth = va_arg(ap, int); char *be_rbuf = va_arg(ap, char *); int be_rbuflen = va_arg(ap, int); struct logentry_proxy_errbe *le = (void *)e->data; le->be_depth = be_depth; le->errlen = strlen(errmsg); if (be_name && be_port) { le->be_namelen = strlen(be_name); le->be_portlen = strlen(be_port); } le->be_rbuflen = be_rbuflen; if (be_rbuflen > MAX_RBUF_READ) { le->be_rbuflen = MAX_RBUF_READ; } char *data = le->data; memcpy(data, errmsg, le->errlen); data += le->errlen; memcpy(data, be_name, le->be_namelen); data += le->be_namelen; memcpy(data, be_port, le->be_portlen); data += le->be_portlen; memcpy(data, be_rbuf, le->be_rbuflen); data += le->be_rbuflen; e->size = sizeof(struct logentry_proxy_errbe) + (data - le->data); } static int _logger_parse_prx_errbe(logentry *e, char *scratch) { int total; char rbuf[MAX_RBUF_READ * 3]; // x 3 for worst case URI encoding. struct logentry_proxy_errbe *le = (void *)e->data; char *data = le->data; char *errmsg = data; data += le->errlen; char *be_name = data; data += le->be_namelen; char *be_port = data; data += le->be_portlen; char *be_rbuf = data; uriencode(be_rbuf, rbuf, le->be_rbuflen, MAX_RBUF_READ * 3); total = snprintf(scratch, LOGGER_PARSE_SCRATCH, "ts=%lld.%d gid=%llu type=proxy_backend error=%.*s name=%.*s port=%.*s depth=%d rbuf=%s\n", (long long int)e->tv.tv_sec, (int)e->tv.tv_usec, (unsigned long long) e->gid, (int)le->errlen, errmsg, (int)le->be_namelen, be_name, (int)le->be_portlen, be_port, le->be_depth, rbuf); return total; } #endif /* Should this go somewhere else? */ static const entry_details default_entries[] = { [LOGGER_ASCII_CMD] = {512, LOG_RAWCMDS, _logger_log_text, _logger_parse_text, "<%d %s"}, [LOGGER_EVICTION] = {512, LOG_EVICTIONS, _logger_log_evictions, _logger_parse_ee, NULL}, [LOGGER_ITEM_GET] = {512, LOG_FETCHERS, _logger_log_item_get, _logger_parse_ige, NULL}, [LOGGER_ITEM_STORE] = {512, LOG_MUTATIONS, _logger_log_item_store, _logger_parse_ise, NULL}, [LOGGER_CRAWLER_STATUS] = {512, LOG_SYSEVENTS, _logger_log_text, _logger_parse_text, "type=lru_crawler crawler=%d lru=%s low_mark=%llu next_reclaims=%llu since_run=%u next_run=%d elapsed=%u examined=%llu reclaimed=%llu" }, [LOGGER_SLAB_MOVE] = {512, LOG_SYSEVENTS, _logger_log_text, _logger_parse_text, "type=slab_move src=%d dst=%d" }, [LOGGER_CONNECTION_NEW] = {512, LOG_CONNEVENTS, _logger_log_conn_event, _logger_parse_cne, NULL}, [LOGGER_CONNECTION_CLOSE] = {512, LOG_CONNEVENTS, _logger_log_conn_event, _logger_parse_cce, NULL}, [LOGGER_DELETIONS] = {512, LOG_DELETIONS, _logger_log_item_deleted, _logger_parse_ide, NULL}, #ifdef EXTSTORE [LOGGER_EXTSTORE_WRITE] = {512, LOG_EVICTIONS, _logger_log_ext_write, _logger_parse_extw, NULL}, [LOGGER_COMPACT_START] = {512, LOG_SYSEVENTS, _logger_log_text, _logger_parse_text, "type=compact_start id=%lu version=%llu" }, [LOGGER_COMPACT_ABORT] = {512, LOG_SYSEVENTS, _logger_log_text, _logger_parse_text, "type=compact_abort id=%lu" }, [LOGGER_COMPACT_READ_START] = {512, LOG_SYSEVENTS, _logger_log_text, _logger_parse_text, "type=compact_read_start id=%lu offset=%llu" }, [LOGGER_COMPACT_READ_END] = {512, LOG_SYSEVENTS, _logger_log_text, _logger_parse_text, "type=compact_read_end id=%lu offset=%llu rescues=%lu lost=%lu skipped=%lu" }, [LOGGER_COMPACT_END] = {512, LOG_SYSEVENTS, _logger_log_text, _logger_parse_text, "type=compact_end id=%lu" }, [LOGGER_COMPACT_FRAGINFO] = {512, LOG_SYSEVENTS, _logger_log_text, _logger_parse_text, "type=compact_fraginfo ratio=%.2f bytes=%lu" }, #endif #ifdef PROXY [LOGGER_PROXY_CONFIG] = {512, LOG_PROXYEVENTS, _logger_log_text, _logger_parse_text, "type=proxy_conf status=%s" }, [LOGGER_PROXY_REQ] = {1024, LOG_PROXYREQS, _logger_log_proxy_req, _logger_parse_prx_req, NULL}, [LOGGER_PROXY_ERROR] = {512, LOG_PROXYEVENTS, _logger_log_text, _logger_parse_text, "type=proxy_error msg=%s" }, [LOGGER_PROXY_USER] = {512, LOG_PROXYUSER, _logger_log_text, _logger_parse_text, "type=proxy_user msg=%s" }, [LOGGER_PROXY_BE_ERROR] = {512, LOG_PROXYEVENTS, _logger_log_proxy_errbe, _logger_parse_prx_errbe, NULL }, #endif }; /************************* * Util functions shared between bg thread and workers *************************/ /* Logger GID's can be used by watchers to put logs back into strict order */ static uint64_t logger_gid = 0; uint64_t logger_get_gid(void) { #ifdef HAVE_GCC_64ATOMICS return __sync_add_and_fetch(&logger_gid, 1); #elif defined(__sun) return atomic_inc_64_nv(&logger_gid); #else mutex_lock(&logger_atomics_mutex); uint64_t res = ++logger_gid; mutex_unlock(&logger_atomics_mutex); return res; #endif } void logger_set_gid(uint64_t gid) { #ifdef HAVE_GCC_64ATOMICS __sync_add_and_fetch(&logger_gid, gid); #elif defined(__sun) atomic_add_64(&logger_gid); #else mutex_lock(&logger_atomics_mutex); logger_gid = gid; mutex_unlock(&logger_atomics_mutex); #endif } /* TODO: genericize lists. would be nice to import queue.h if the impact is * studied... otherwise can just write a local one. */ /* Add to the list of threads with a logger object */ static void logger_link_q(logger *l) { pthread_mutex_lock(&logger_stack_lock); assert(l != logger_stack_head); l->prev = 0; l->next = logger_stack_head; if (l->next) l->next->prev = l; logger_stack_head = l; if (logger_stack_tail == 0) logger_stack_tail = l; logger_count++; pthread_mutex_unlock(&logger_stack_lock); return; } /* Remove from the list of threads with a logger object */ /*static void logger_unlink_q(logger *l) { pthread_mutex_lock(&logger_stack_lock); if (logger_stack_head == l) { assert(l->prev == 0); logger_stack_head = l->next; } if (logger_stack_tail == l) { assert(l->next == 0); logger_stack_tail = l->prev; } assert(l->next != l); assert(l->prev != l); if (l->next) l->next->prev = l->prev; if (l->prev) l->prev->next = l->next; logger_count--; pthread_mutex_unlock(&logger_stack_lock); return; }*/ /* Called with logger stack locked. * Iterates over every watcher collecting enabled flags. */ static void logger_set_flags(void) { logger *l = NULL; int x = 0; uint16_t f = 0; /* logger eflags */ for (x = 0; x < WATCHER_LIMIT; x++) { logger_watcher *w = watchers[x]; if (w == NULL) continue; f |= w->eflags; } for (l = logger_stack_head; l != NULL; l=l->next) { pthread_mutex_lock(&l->mutex); l->eflags = f; pthread_mutex_unlock(&l->mutex); } return; } /* Completes rendering of log line. */ static enum logger_parse_entry_ret logger_thread_parse_entry(logentry *e, struct logger_stats *ls, char *scratch, int *scratch_len) { int total = 0; const entry_details *d = &default_entries[e->event]; assert(d->parse_cb != NULL); total = d->parse_cb(e, scratch); if (total >= LOGGER_PARSE_SCRATCH || total <= 0) { L_DEBUG("LOGGER: Failed to flatten log entry!\n"); return LOGGER_PARSE_ENTRY_FAILED; } else { *scratch_len = total; } return LOGGER_PARSE_ENTRY_OK; } /* Writes flattened entry to available watchers */ static void logger_thread_write_entry(logentry *e, struct logger_stats *ls, char *scratch, int scratch_len) { int x, total; /* Write the line into available watchers with matching flags */ for (x = 0; x < WATCHER_LIMIT; x++) { logger_watcher *w = watchers[x]; char *skip_scr = NULL; if (w == NULL || (e->eflags & w->eflags) == 0 || (e->gid < w->min_gid)) continue; /* Avoid poll()'ing constantly when buffer is full by resetting a * flag periodically. */ while (!w->failed_flush && (skip_scr = (char *) bipbuf_request(w->buf, scratch_len + 128)) == NULL) { if (logger_thread_poll_watchers(0, x) <= 0) { L_DEBUG("LOGGER: Watcher had no free space for line of size (%d)\n", scratch_len + 128); w->failed_flush = true; } } if (w->failed_flush) { L_DEBUG("LOGGER: Fast skipped for watcher [%d] due to failed_flush\n", w->sfd); w->skipped++; ls->watcher_skipped++; continue; } if (w->skipped > 0) { total = snprintf(skip_scr, 128, "skipped=%llu\n", (unsigned long long) w->skipped); if (total >= 128 || total <= 0) { L_DEBUG("LOGGER: Failed to flatten skipped message into watcher [%d]\n", w->sfd); w->skipped++; ls->watcher_skipped++; continue; } bipbuf_push(w->buf, total); w->skipped = 0; } /* Can't fail because bipbuf_request succeeded. */ bipbuf_offer(w->buf, (unsigned char *) scratch, scratch_len); ls->watcher_sent++; } } /* Called with logger stack locked. * Releases every chunk associated with a watcher and closes the connection. * We can't presently send a connection back to the worker for further * processing. */ static void logger_thread_close_watcher(logger_watcher *w) { L_DEBUG("LOGGER: Closing dead watcher\n"); watchers[w->id] = NULL; sidethread_conn_close(w->c); watcher_count--; bipbuf_free(w->buf); free(w); logger_set_flags(); } /* Reads a particular worker thread's available bipbuf bytes. Parses each log * entry into the watcher buffers. */ static int logger_thread_read(logger *l, struct logger_stats *ls) { unsigned int size; unsigned int pos = 0; unsigned char *data; char scratch[LOGGER_PARSE_SCRATCH]; logentry *e; pthread_mutex_lock(&l->mutex); data = bipbuf_peek_all(l->buf, &size); pthread_mutex_unlock(&l->mutex); if (data == NULL) { return 0; } L_DEBUG("LOGGER: Got %d bytes from bipbuffer\n", size); /* parse buffer */ while (pos < size && watcher_count > 0) { enum logger_parse_entry_ret ret; int scratch_len = 0; e = (logentry *) (data + pos); ret = logger_thread_parse_entry(e, ls, scratch, &scratch_len); if (ret != LOGGER_PARSE_ENTRY_OK) { /* TODO: stats counter */ fprintf(stderr, "LOGGER: Failed to parse log entry\n"); } else { logger_thread_write_entry(e, ls, scratch, scratch_len); } pos += sizeof(logentry) + e->size + e->pad; } assert(pos <= size); pthread_mutex_lock(&l->mutex); data = bipbuf_poll(l->buf, size); ls->worker_written += l->written; ls->worker_dropped += l->dropped; l->written = 0; l->dropped = 0; pthread_mutex_unlock(&l->mutex); if (data == NULL) { fprintf(stderr, "LOGGER: unexpectedly couldn't advance buf pointer\n"); assert(0); } return size; /* maybe the count of objects iterated? */ } /* Since the event loop code isn't reusable without a refactor, and we have a * limited number of potential watchers, we run our own poll loop. * This calls poll() unnecessarily during write flushes, should be possible to * micro-optimize later. * * This flushes buffers attached to watchers, iterating through the bytes set * to each worker. Also checks for readability in case client connection was * closed. * * Allows a specific watcher to be flushed (if buf full) */ static int logger_thread_poll_watchers(int force_poll, int watcher) { int x; int nfd = 0; unsigned char *data; unsigned int data_size = 0; int flushed = 0; for (x = 0; x < WATCHER_LIMIT; x++) { logger_watcher *w = watchers[x]; if (w == NULL || (watcher != WATCHER_ALL && x != watcher)) continue; data = bipbuf_peek_all(w->buf, &data_size); if (data != NULL) { watchers_pollfds[nfd].fd = w->sfd; watchers_pollfds[nfd].events = POLLOUT; nfd++; } else if (force_poll) { watchers_pollfds[nfd].fd = w->sfd; watchers_pollfds[nfd].events = POLLIN; nfd++; } /* This gets set after a call to poll, and should be used to gate on * calling poll again. */ w->failed_flush = false; } if (nfd == 0) return 0; //L_DEBUG("LOGGER: calling poll() [data_size: %d]\n", data_size); int ret = poll(watchers_pollfds, nfd, 0); if (ret < 0) { perror("something failed with logger thread watcher fd polling"); return -1; } nfd = 0; for (x = 0; x < WATCHER_LIMIT; x++) { logger_watcher *w = watchers[x]; if (w == NULL || (watcher != WATCHER_ALL && x != watcher)) continue; data_size = 0; /* Early detection of a disconnect. Otherwise we have to wait until * the next write */ if (watchers_pollfds[nfd].revents & POLLIN) { char buf[1]; int res = ((conn*)w->c)->read(w->c, buf, 1); if (res == 0 || (res == -1 && (errno != EAGAIN && errno != EWOULDBLOCK))) { L_DEBUG("LOGGER: watcher closed remotely\n"); logger_thread_close_watcher(w); nfd++; continue; } } if ((data = bipbuf_peek_all(w->buf, &data_size)) != NULL) { if (watchers_pollfds[nfd].revents & (POLLHUP|POLLERR)) { L_DEBUG("LOGGER: watcher closed during poll() call\n"); logger_thread_close_watcher(w); } else if (watchers_pollfds[nfd].revents & POLLOUT) { int total = 0; /* We can write a bit. */ switch (w->t) { case LOGGER_WATCHER_STDERR: total = fwrite(data, 1, data_size, stderr); break; case LOGGER_WATCHER_CLIENT: total = ((conn*)w->c)->write(w->c, data, data_size); break; } L_DEBUG("LOGGER: poll() wrote %d to %d (data_size: %d) (bipbuf_used: %d)\n", total, w->sfd, data_size, bipbuf_used(w->buf)); if (total == -1) { if (errno != EAGAIN && errno != EWOULDBLOCK) { logger_thread_close_watcher(w); } L_DEBUG("LOGGER: watcher hit EAGAIN\n"); } else if (total == 0) { logger_thread_close_watcher(w); } else { bipbuf_poll(w->buf, total); flushed += total; } } } nfd++; } return flushed; } static void logger_thread_flush_stats(struct logger_stats *ls) { STATS_LOCK(); stats.log_worker_dropped += ls->worker_dropped; stats.log_worker_written += ls->worker_written; stats.log_watcher_skipped += ls->watcher_skipped; stats.log_watcher_sent += ls->watcher_sent; stats_state.log_watchers = ls->watcher_count; STATS_UNLOCK(); } #define MAX_LOGGER_SLEEP 1000000 #define MIN_LOGGER_SLEEP 1000 /* Primary logger thread routine */ static void *logger_thread(void *arg) { useconds_t to_sleep = MIN_LOGGER_SLEEP; L_DEBUG("LOGGER: Starting logger thread\n"); // TODO: If we ever have item references in the logger code, will need to // ensure everything is dequeued before stopping the thread. while (do_run_logger_thread) { int found_logs = 0; logger *l; struct logger_stats ls; memset(&ls, 0, sizeof(struct logger_stats)); /* only sleep if we're *above* the minimum */ if (to_sleep > MIN_LOGGER_SLEEP) usleep(to_sleep); /* Call function to iterate each logger. */ pthread_mutex_lock(&logger_stack_lock); if (watcher_count == 0) { // Not bothering to loop on the condition here since it's fine to // walk through with zero watchers. pthread_cond_wait(&logger_stack_cond, &logger_stack_lock); } for (l = logger_stack_head; l != NULL; l=l->next) { /* lock logger, call function to manipulate it */ found_logs += logger_thread_read(l, &ls); } logger_thread_poll_watchers(1, WATCHER_ALL); /* capture the current count within mutual exclusion of the lock */ ls.watcher_count = watcher_count; pthread_mutex_unlock(&logger_stack_lock); /* TODO: abstract into a function and share with lru_crawler */ if (!found_logs) { if (to_sleep < MAX_LOGGER_SLEEP) to_sleep += to_sleep / 8; if (to_sleep > MAX_LOGGER_SLEEP) to_sleep = MAX_LOGGER_SLEEP; } else { to_sleep /= 2; if (to_sleep < MIN_LOGGER_SLEEP) to_sleep = MIN_LOGGER_SLEEP; } logger_thread_flush_stats(&ls); } return NULL; } static int start_logger_thread(void) { int ret; do_run_logger_thread = 1; if ((ret = pthread_create(&logger_tid, NULL, logger_thread, NULL)) != 0) { fprintf(stderr, "Can't start logger thread: %s\n", strerror(ret)); return -1; } thread_setname(logger_tid, "mc-log"); return 0; } static int stop_logger_thread(void) { // Guarantees that the logger thread is waiting on 'logger_stack_cond' // before we signal it. pthread_mutex_lock(&logger_stack_lock); do_run_logger_thread = 0; pthread_cond_signal(&logger_stack_cond); pthread_mutex_unlock(&logger_stack_lock); pthread_join(logger_tid, NULL); return 0; } /************************* * Public functions for submitting logs and starting loggers from workers. *************************/ /* Global logger thread start/init */ void logger_init(void) { /* TODO: auto destructor when threads exit */ /* TODO: error handling */ /* init stack for iterating loggers */ logger_stack_head = 0; logger_stack_tail = 0; pthread_key_create(&logger_key, NULL); if (start_logger_thread() != 0) { abort(); } /* This is what adding a STDERR watcher looks like. should replace old * "verbose" settings. */ //logger_add_watcher(NULL, 0); return; } void logger_stop(void) { stop_logger_thread(); } /* called *from* the thread using a logger. * initializes the per-thread bipbuf, links it into the list of loggers */ logger *logger_create(void) { L_DEBUG("LOGGER: Creating and linking new logger instance\n"); logger *l = calloc(1, sizeof(logger)); if (l == NULL) { return NULL; } l->buf = bipbuf_new(settings.logger_buf_size); if (l->buf == NULL) { free(l); return NULL; } l->entry_map = default_entries; pthread_mutex_init(&l->mutex, NULL); pthread_setspecific(logger_key, l); /* add to list of loggers */ logger_link_q(l); return l; } /* Public function for logging an entry. * Tries to encapsulate as much of the formatting as possible to simplify the * caller's code. */ enum logger_ret_type logger_log(logger *l, const enum log_entry_type event, const void *entry, ...) { bipbuf_t *buf = l->buf; bool nospace = false; va_list ap; logentry *e; const entry_details *d = &l->entry_map[event]; int reqlen = d->reqlen; pthread_mutex_lock(&l->mutex); /* Request a maximum length of data to write to */ e = (logentry *) bipbuf_request(buf, (sizeof(logentry) + reqlen)); if (e == NULL) { l->dropped++; pthread_mutex_unlock(&l->mutex); return LOGGER_RET_NOSPACE; } e->event = event; e->pad = 0; e->gid = logger_get_gid(); /* TODO: Could pass this down as an argument now that we're using * LOGGER_LOG() macro. */ e->eflags = d->eflags; /* Noting time isn't optional. A feature may be added to avoid rendering * time and/or gid to a logger. */ gettimeofday(&e->tv, NULL); va_start(ap, entry); d->log_cb(e, d, entry, ap); va_end(ap); #ifdef NEED_ALIGN /* Need to ensure *next* request is aligned. */ if (sizeof(logentry) + e->size % 8 != 0) { e->pad = 8 - (sizeof(logentry) + e->size % 8); } #endif /* Push pointer forward by the actual amount required */ if (bipbuf_push(buf, (sizeof(logentry) + e->size + e->pad)) == 0) { fprintf(stderr, "LOGGER: Failed to bipbuf push a text entry\n"); pthread_mutex_unlock(&l->mutex); return LOGGER_RET_ERR; } l->written++; L_DEBUG("LOGGER: Requested %d bytes, wrote %lu bytes\n", reqlen, (sizeof(logentry) + e->size)); pthread_mutex_unlock(&l->mutex); if (nospace) { return LOGGER_RET_NOSPACE; } else { return LOGGER_RET_OK; } } /* Passes a client connection socket from a primary worker thread to the * logger thread. Caller *must* event_del() the client before handing it over. * Presently there's no way to hand the client back to the worker thread. */ enum logger_add_watcher_ret logger_add_watcher(void *c, const int sfd, uint16_t f) { int x; logger_watcher *w = NULL; pthread_mutex_lock(&logger_stack_lock); if (watcher_count >= WATCHER_LIMIT) { pthread_mutex_unlock(&logger_stack_lock); return LOGGER_ADD_WATCHER_TOO_MANY; } for (x = 0; x < WATCHER_LIMIT-1; x++) { if (watchers[x] == NULL) break; } w = calloc(1, sizeof(logger_watcher)); if (w == NULL) { pthread_mutex_unlock(&logger_stack_lock); return LOGGER_ADD_WATCHER_FAILED; } w->c = c; w->sfd = sfd; if (sfd == 0 && c == NULL) { w->t = LOGGER_WATCHER_STDERR; } else { w->t = LOGGER_WATCHER_CLIENT; } w->id = x; w->eflags = f; w->min_gid = logger_get_gid(); w->buf = bipbuf_new(settings.logger_watcher_buf_size); if (w->buf == NULL) { free(w); pthread_mutex_unlock(&logger_stack_lock); return LOGGER_ADD_WATCHER_FAILED; } bipbuf_offer(w->buf, (unsigned char *) "OK\r\n", 4); watchers[x] = w; watcher_count++; /* Update what flags the global logs will watch */ logger_set_flags(); pthread_cond_signal(&logger_stack_cond); pthread_mutex_unlock(&logger_stack_lock); return LOGGER_ADD_WATCHER_OK; } memcached-1.6.20/proto_proxy.h0000664000175000017500000000163614403667314013224 00000000000000#ifndef PROTO_PROXY_H #define PROTO_PROXY_H void proxy_stats(void *arg, ADD_STAT add_stats, conn *c); void process_proxy_stats(void *arg, ADD_STAT add_stats, conn *c); /* proxy mode handlers */ int try_read_command_proxy(conn *c); void complete_nread_proxy(conn *c); void proxy_cleanup_conn(conn *c); void proxy_thread_init(void *ctx, LIBEVENT_THREAD *thr); void *proxy_init(bool proxy_uring); // TODO: need better names or a better interface for these. can be confusing // to reason about the order. void proxy_start_reload(void *arg); int proxy_first_confload(void *arg); int proxy_load_config(void *arg); void proxy_worker_reload(void *arg, LIBEVENT_THREAD *thr); void proxy_submit_cb(io_queue_t *q); void proxy_complete_cb(io_queue_t *q); void proxy_return_cb(io_pending_t *pending); void proxy_finalize_cb(io_pending_t *pending); /* lua */ int proxy_register_libs(void *ctx, LIBEVENT_THREAD *t, void *state); #endif memcached-1.6.20/compile0000755000175000017500000001635014215102164012006 00000000000000#! /bin/sh # Wrapper for compilers which do not understand '-c -o'. scriptversion=2018-03-07.03; # UTC # Copyright (C) 1999-2021 Free Software Foundation, Inc. # Written by Tom Tromey . # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # This file is maintained in Automake, please report # bugs to or send patches to # . nl=' ' # We need space, tab and new line, in precisely that order. Quoting is # there to prevent tools from complaining about whitespace usage. IFS=" "" $nl" file_conv= # func_file_conv build_file lazy # Convert a $build file to $host form and store it in $file # Currently only supports Windows hosts. If the determined conversion # type is listed in (the comma separated) LAZY, no conversion will # take place. func_file_conv () { file=$1 case $file in / | /[!/]*) # absolute file, and not a UNC file if test -z "$file_conv"; then # lazily determine how to convert abs files case `uname -s` in MINGW*) file_conv=mingw ;; CYGWIN* | MSYS*) file_conv=cygwin ;; *) file_conv=wine ;; esac fi case $file_conv/,$2, in *,$file_conv,*) ;; mingw/*) file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'` ;; cygwin/* | msys/*) file=`cygpath -m "$file" || echo "$file"` ;; wine/*) file=`winepath -w "$file" || echo "$file"` ;; esac ;; esac } # func_cl_dashL linkdir # Make cl look for libraries in LINKDIR func_cl_dashL () { func_file_conv "$1" if test -z "$lib_path"; then lib_path=$file else lib_path="$lib_path;$file" fi linker_opts="$linker_opts -LIBPATH:$file" } # func_cl_dashl library # Do a library search-path lookup for cl func_cl_dashl () { lib=$1 found=no save_IFS=$IFS IFS=';' for dir in $lib_path $LIB do IFS=$save_IFS if $shared && test -f "$dir/$lib.dll.lib"; then found=yes lib=$dir/$lib.dll.lib break fi if test -f "$dir/$lib.lib"; then found=yes lib=$dir/$lib.lib break fi if test -f "$dir/lib$lib.a"; then found=yes lib=$dir/lib$lib.a break fi done IFS=$save_IFS if test "$found" != yes; then lib=$lib.lib fi } # func_cl_wrapper cl arg... # Adjust compile command to suit cl func_cl_wrapper () { # Assume a capable shell lib_path= shared=: linker_opts= for arg do if test -n "$eat"; then eat= else case $1 in -o) # configure might choose to run compile as 'compile cc -o foo foo.c'. eat=1 case $2 in *.o | *.[oO][bB][jJ]) func_file_conv "$2" set x "$@" -Fo"$file" shift ;; *) func_file_conv "$2" set x "$@" -Fe"$file" shift ;; esac ;; -I) eat=1 func_file_conv "$2" mingw set x "$@" -I"$file" shift ;; -I*) func_file_conv "${1#-I}" mingw set x "$@" -I"$file" shift ;; -l) eat=1 func_cl_dashl "$2" set x "$@" "$lib" shift ;; -l*) func_cl_dashl "${1#-l}" set x "$@" "$lib" shift ;; -L) eat=1 func_cl_dashL "$2" ;; -L*) func_cl_dashL "${1#-L}" ;; -static) shared=false ;; -Wl,*) arg=${1#-Wl,} save_ifs="$IFS"; IFS=',' for flag in $arg; do IFS="$save_ifs" linker_opts="$linker_opts $flag" done IFS="$save_ifs" ;; -Xlinker) eat=1 linker_opts="$linker_opts $2" ;; -*) set x "$@" "$1" shift ;; *.cc | *.CC | *.cxx | *.CXX | *.[cC]++) func_file_conv "$1" set x "$@" -Tp"$file" shift ;; *.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO]) func_file_conv "$1" mingw set x "$@" "$file" shift ;; *) set x "$@" "$1" shift ;; esac fi shift done if test -n "$linker_opts"; then linker_opts="-link$linker_opts" fi exec "$@" $linker_opts exit 1 } eat= case $1 in '') echo "$0: No command. Try '$0 --help' for more information." 1>&2 exit 1; ;; -h | --h*) cat <<\EOF Usage: compile [--help] [--version] PROGRAM [ARGS] Wrapper for compilers which do not understand '-c -o'. Remove '-o dest.o' from ARGS, run PROGRAM with the remaining arguments, and rename the output as expected. If you are trying to build a whole package this is not the right script to run: please start by reading the file 'INSTALL'. Report bugs to . EOF exit $? ;; -v | --v*) echo "compile $scriptversion" exit $? ;; cl | *[/\\]cl | cl.exe | *[/\\]cl.exe | \ icl | *[/\\]icl | icl.exe | *[/\\]icl.exe ) func_cl_wrapper "$@" # Doesn't return... ;; esac ofile= cfile= for arg do if test -n "$eat"; then eat= else case $1 in -o) # configure might choose to run compile as 'compile cc -o foo foo.c'. # So we strip '-o arg' only if arg is an object. eat=1 case $2 in *.o | *.obj) ofile=$2 ;; *) set x "$@" -o "$2" shift ;; esac ;; *.c) cfile=$1 set x "$@" "$1" shift ;; *) set x "$@" "$1" shift ;; esac fi shift done if test -z "$ofile" || test -z "$cfile"; then # If no '-o' option was seen then we might have been invoked from a # pattern rule where we don't need one. That is ok -- this is a # normal compilation that the losing compiler can handle. If no # '.c' file was seen then we are probably linking. That is also # ok. exec "$@" fi # Name of file we expect compiler to create. cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'` # Create the lock directory. # Note: use '[/\\:.-]' here to ensure that we don't use the same name # that we are using for the .o file. Also, base the name on the expected # object file name, since that is what matters with a parallel build. lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d while true; do if mkdir "$lockdir" >/dev/null 2>&1; then break fi sleep 1 done # FIXME: race condition here if user kills between mkdir and trap. trap "rmdir '$lockdir'; exit 1" 1 2 15 # Run the compile. "$@" ret=$? if test -f "$cofile"; then test "$cofile" = "$ofile" || mv "$cofile" "$ofile" elif test -f "${cofile}bj"; then test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile" fi rmdir "$lockdir" exit $ret # Local Variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC0" # time-stamp-end: "; # UTC" # End: memcached-1.6.20/crawler.c0000664000175000017500000006672214403667314012261 00000000000000/* Copyright 2016 Netflix. * * Use and distribution licensed under the BSD license. See * the LICENSE file for full text. */ /* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "memcached.h" #include "storage.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "base64.h" #define LARGEST_ID POWER_LARGEST typedef struct { void *c; /* original connection structure. still with source thread attached. */ int sfd; /* client fd. */ int buflen; int bufused; char *buf; /* output buffer */ } crawler_client_t; typedef struct _crawler_module_t crawler_module_t; typedef void (*crawler_eval_func)(crawler_module_t *cm, item *it, uint32_t hv, int slab_cls); typedef int (*crawler_init_func)(crawler_module_t *cm, void *data); // TODO: init args? typedef void (*crawler_deinit_func)(crawler_module_t *cm); // TODO: extra args? typedef void (*crawler_doneclass_func)(crawler_module_t *cm, int slab_cls); typedef void (*crawler_finalize_func)(crawler_module_t *cm); typedef struct { crawler_init_func init; /* run before crawl starts */ crawler_eval_func eval; /* runs on an item. */ crawler_doneclass_func doneclass; /* runs once per sub-crawler completion. */ crawler_finalize_func finalize; /* runs once when all sub-crawlers are done. */ bool needs_lock; /* whether or not we need the LRU lock held when eval is called */ bool needs_client; /* whether or not to grab onto the remote client */ } crawler_module_reg_t; struct _crawler_module_t { void *data; /* opaque data pointer */ crawler_client_t c; crawler_module_reg_t *mod; }; static int crawler_expired_init(crawler_module_t *cm, void *data); static void crawler_expired_doneclass(crawler_module_t *cm, int slab_cls); static void crawler_expired_finalize(crawler_module_t *cm); static void crawler_expired_eval(crawler_module_t *cm, item *search, uint32_t hv, int i); crawler_module_reg_t crawler_expired_mod = { .init = crawler_expired_init, .eval = crawler_expired_eval, .doneclass = crawler_expired_doneclass, .finalize = crawler_expired_finalize, .needs_lock = true, .needs_client = false }; static void crawler_metadump_eval(crawler_module_t *cm, item *search, uint32_t hv, int i); static void crawler_metadump_finalize(crawler_module_t *cm); crawler_module_reg_t crawler_metadump_mod = { .init = NULL, .eval = crawler_metadump_eval, .doneclass = NULL, .finalize = crawler_metadump_finalize, .needs_lock = false, .needs_client = true }; static void crawler_mgdump_eval(crawler_module_t *cm, item *search, uint32_t hv, int i); static void crawler_mgdump_finalize(crawler_module_t *cm); crawler_module_reg_t crawler_mgdump_mod = { .init = NULL, .eval = crawler_mgdump_eval, .doneclass = NULL, .finalize = crawler_mgdump_finalize, .needs_lock = false, .needs_client = true }; crawler_module_reg_t *crawler_mod_regs[4] = { &crawler_expired_mod, &crawler_expired_mod, &crawler_metadump_mod, &crawler_mgdump_mod, }; static int lru_crawler_write(crawler_client_t *c); crawler_module_t active_crawler_mod; enum crawler_run_type active_crawler_type; static crawler crawlers[LARGEST_ID]; static int crawler_count = 0; static volatile int do_run_lru_crawler_thread = 0; static int lru_crawler_initialized = 0; static pthread_mutex_t lru_crawler_lock = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t lru_crawler_cond = PTHREAD_COND_INITIALIZER; #ifdef EXTSTORE /* TODO: pass this around */ static void *storage; #endif /* Will crawl all slab classes a minimum of once per hour */ #define MAX_MAINTCRAWL_WAIT 60 * 60 /*** LRU CRAWLER THREAD ***/ #define LRU_CRAWLER_MINBUFSPACE 8192 static void lru_crawler_close_client(crawler_client_t *c) { //fprintf(stderr, "CRAWLER: Closing client\n"); sidethread_conn_close(c->c); c->c = NULL; free(c->buf); c->buf = NULL; } static void lru_crawler_release_client(crawler_client_t *c) { //fprintf(stderr, "CRAWLER: Closing client\n"); redispatch_conn(c->c); c->c = NULL; free(c->buf); c->buf = NULL; } static int lru_crawler_expand_buf(crawler_client_t *c) { c->buflen *= 2; char *nb = realloc(c->buf, c->buflen); if (nb == NULL) { return -1; } c->buf = nb; return 0; } static int crawler_expired_init(crawler_module_t *cm, void *data) { struct crawler_expired_data *d; if (data != NULL) { d = data; d->is_external = true; cm->data = data; } else { // allocate data. d = calloc(1, sizeof(struct crawler_expired_data)); if (d == NULL) { return -1; } // init lock. pthread_mutex_init(&d->lock, NULL); d->is_external = false; d->start_time = current_time; cm->data = d; } pthread_mutex_lock(&d->lock); memset(&d->crawlerstats, 0, sizeof(crawlerstats_t) * POWER_LARGEST); for (int x = 0; x < POWER_LARGEST; x++) { d->crawlerstats[x].start_time = current_time; d->crawlerstats[x].run_complete = false; } pthread_mutex_unlock(&d->lock); return 0; } static void crawler_expired_doneclass(crawler_module_t *cm, int slab_cls) { struct crawler_expired_data *d = (struct crawler_expired_data *) cm->data; pthread_mutex_lock(&d->lock); d->crawlerstats[slab_cls].end_time = current_time; d->crawlerstats[slab_cls].run_complete = true; pthread_mutex_unlock(&d->lock); } static void crawler_expired_finalize(crawler_module_t *cm) { struct crawler_expired_data *d = (struct crawler_expired_data *) cm->data; pthread_mutex_lock(&d->lock); d->end_time = current_time; d->crawl_complete = true; pthread_mutex_unlock(&d->lock); if (!d->is_external) { free(d); } } /* I pulled this out to make the main thread clearer, but it reaches into the * main thread's values too much. Should rethink again. */ static void crawler_expired_eval(crawler_module_t *cm, item *search, uint32_t hv, int i) { struct crawler_expired_data *d = (struct crawler_expired_data *) cm->data; pthread_mutex_lock(&d->lock); crawlerstats_t *s = &d->crawlerstats[i]; int is_flushed = item_is_flushed(search); #ifdef EXTSTORE bool is_valid = true; if (search->it_flags & ITEM_HDR) { is_valid = storage_validate_item(storage, search); } #endif if ((search->exptime != 0 && search->exptime < current_time) || is_flushed #ifdef EXTSTORE || !is_valid #endif ) { crawlers[i].reclaimed++; s->reclaimed++; if (settings.verbose > 1) { int ii; char *key = ITEM_key(search); fprintf(stderr, "LRU crawler found an expired item (flags: %d, slab: %d): ", search->it_flags, search->slabs_clsid); for (ii = 0; ii < search->nkey; ++ii) { fprintf(stderr, "%c", key[ii]); } fprintf(stderr, "\n"); } if ((search->it_flags & ITEM_FETCHED) == 0 && !is_flushed) { crawlers[i].unfetched++; } #ifdef EXTSTORE STORAGE_delete(storage, search); #endif do_item_unlink_nolock(search, hv); do_item_remove(search); } else { s->seen++; refcount_decr(search); if (search->exptime == 0) { s->noexp++; } else if (search->exptime - current_time > 3599) { s->ttl_hourplus++; } else { rel_time_t ttl_remain = search->exptime - current_time; int bucket = ttl_remain / 60; if (bucket <= 60) { s->histo[bucket]++; } } } pthread_mutex_unlock(&d->lock); } static void crawler_metadump_eval(crawler_module_t *cm, item *it, uint32_t hv, int i) { char keybuf[KEY_MAX_URI_ENCODED_LENGTH]; int is_flushed = item_is_flushed(it); /* Ignore expired content. */ if ((it->exptime != 0 && it->exptime < current_time) || is_flushed) { refcount_decr(it); return; } // TODO: uriencode directly into the buffer. uriencode(ITEM_key(it), keybuf, it->nkey, KEY_MAX_URI_ENCODED_LENGTH); int total = snprintf(cm->c.buf + cm->c.bufused, 4096, "key=%s exp=%ld la=%llu cas=%llu fetch=%s cls=%u size=%lu\n", keybuf, (it->exptime == 0) ? -1 : (long)(it->exptime + process_started), (unsigned long long)(it->time + process_started), (unsigned long long)ITEM_get_cas(it), (it->it_flags & ITEM_FETCHED) ? "yes" : "no", ITEM_clsid(it), (unsigned long) ITEM_ntotal(it)); refcount_decr(it); // TODO: some way of tracking the errors. these should be impossible given // the space requirements. if (total >= LRU_CRAWLER_MINBUFSPACE - 1 || total <= 0) { // Failed to write, don't push it. return; } cm->c.bufused += total; } static void crawler_metadump_finalize(crawler_module_t *cm) { if (cm->c.c != NULL) { lru_crawler_write(&cm->c); // empty the write buffer memcpy(cm->c.buf, "END\r\n", 5); cm->c.bufused += 5; } } static void crawler_mgdump_eval(crawler_module_t *cm, item *it, uint32_t hv, int i) { int is_flushed = item_is_flushed(it); /* Ignore expired content. */ if ((it->exptime != 0 && it->exptime < current_time) || is_flushed) { refcount_decr(it); return; } char *p = cm->c.buf + cm->c.bufused; // buffer offset. char *start = p; memcpy(p, "mg ", 3); p += 3; if (it->it_flags & ITEM_KEY_BINARY) { p += base64_encode((unsigned char *) ITEM_key(it), it->nkey, (unsigned char*) p, LRU_CRAWLER_MINBUFSPACE/2); memcpy(p, " b\r\n", 4); p += 4; } else { memcpy(p, ITEM_key(it), it->nkey); p += it->nkey; memcpy(p, "\r\n", 2); p += 2; } int total = p - start; refcount_decr(it); cm->c.bufused += total; } static void crawler_mgdump_finalize(crawler_module_t *cm) { if (cm->c.c != NULL) { lru_crawler_write(&cm->c); // empty the write buffer memcpy(cm->c.buf, "EN\r\n", 4); cm->c.bufused += 4; } } // write the whole buffer out to the client socket. static int lru_crawler_write(crawler_client_t *c) { unsigned int data_size = c->bufused; unsigned int sent = 0; struct pollfd to_poll[1]; to_poll[0].fd = c->sfd; to_poll[0].events = POLLOUT; if (c->c == NULL) return -1; if (data_size == 0) return 0; while (sent < data_size) { int ret = poll(to_poll, 1, 1000); if (ret < 0) { // fatal. return -1; } if (ret == 0) return 0; // check if socket was closed on us. if (to_poll[0].revents & POLLIN) { char buf[1]; int res = ((conn*)c->c)->read(c->c, buf, 1); if (res == 0 || (res == -1 && (errno != EAGAIN && errno != EWOULDBLOCK))) { lru_crawler_close_client(c); return -1; } } if (to_poll[0].revents & (POLLHUP|POLLERR)) { // got socket hangup. lru_crawler_close_client(c); return -1; } else if (to_poll[0].revents & POLLOUT) { // socket is writeable. int total = ((conn*)c->c)->write(c->c, c->buf + sent, data_size - sent); if (total == -1) { if (errno != EAGAIN && errno != EWOULDBLOCK) { lru_crawler_close_client(c); return -1; } } else if (total == 0) { lru_crawler_close_client(c); return -1; } sent += total; } } // while // write buffer now empty. c->bufused = 0; return 0; } static void lru_crawler_class_done(int i) { crawlers[i].it_flags = 0; crawler_count--; do_item_unlinktail_q((item *)&crawlers[i]); do_item_stats_add_crawl(i, crawlers[i].reclaimed, crawlers[i].unfetched, crawlers[i].checked); pthread_mutex_unlock(&lru_locks[i]); if (active_crawler_mod.mod->doneclass != NULL) active_crawler_mod.mod->doneclass(&active_crawler_mod, i); } // ensure we build the buffer a little bit to cut down on poll/write syscalls. #define MIN_ITEMS_PER_WRITE 16 static void item_crawl_hash(void) { // get iterator from assoc. can hang for a long time. // - blocks hash expansion void *iter = assoc_get_iterator(); int crawls_persleep = settings.crawls_persleep; item *it = NULL; int items = 0; // loop while iterator returns something // - iterator func handles bucket-walking // - iterator returns with bucket locked. while (assoc_iterate(iter, &it)) { // if iterator returns true but no item, we're inbetween buckets and // can do cleanup work without holding an item lock. if (it == NULL) { if (active_crawler_mod.c.c != NULL) { if (items > MIN_ITEMS_PER_WRITE) { int ret = lru_crawler_write(&active_crawler_mod.c); items = 0; if (ret != 0) { // fail out and finalize. break; } } } else if (active_crawler_mod.mod->needs_client) { // fail out and finalize. break; } // - sleep bits from orig loop if (crawls_persleep <= 0 && settings.lru_crawler_sleep) { pthread_mutex_unlock(&lru_crawler_lock); usleep(settings.lru_crawler_sleep); pthread_mutex_lock(&lru_crawler_lock); crawls_persleep = settings.crawls_persleep; } else if (!settings.lru_crawler_sleep) { // TODO: only cycle lock every N? pthread_mutex_unlock(&lru_crawler_lock); pthread_mutex_lock(&lru_crawler_lock); } continue; } // double check that the item isn't in a transitional state. if (refcount_incr(it) < 2) { refcount_decr(it); continue; } // We're presently holding an item lock, so we cannot flush the // buffer to the network socket as the syscall is both slow and could // hang waiting for POLLOUT. Instead we must expand the buffer. if (active_crawler_mod.c.c != NULL) { crawler_client_t *c = &active_crawler_mod.c; if (c->buflen - c->bufused < LRU_CRAWLER_MINBUFSPACE) { if (lru_crawler_expand_buf(c) != 0) { // failed to expand buffer, stop. break; } } } // FIXME: missing hv and i are fine for metadump eval, but not fine // for expire eval. active_crawler_mod.mod->eval(&active_crawler_mod, it, 0, 0); crawls_persleep--; items++; } // must finalize or we leave the hash table expansion blocked. assoc_iterate_final(iter); return; } static void *item_crawler_thread(void *arg) { int i; int crawls_persleep = settings.crawls_persleep; pthread_mutex_lock(&lru_crawler_lock); pthread_cond_signal(&lru_crawler_cond); settings.lru_crawler = true; if (settings.verbose > 2) fprintf(stderr, "Starting LRU crawler background thread\n"); while (do_run_lru_crawler_thread) { pthread_cond_wait(&lru_crawler_cond, &lru_crawler_lock); if (crawler_count == -1) { item_crawl_hash(); crawler_count = 0; } else { while (crawler_count) { item *search = NULL; void *hold_lock = NULL; for (i = POWER_SMALLEST; i < LARGEST_ID; i++) { if (crawlers[i].it_flags != 1) { continue; } if (active_crawler_mod.c.c != NULL) { crawler_client_t *c = &active_crawler_mod.c; if (c->buflen - c->bufused < LRU_CRAWLER_MINBUFSPACE) { int ret = lru_crawler_write(c); if (ret != 0) { lru_crawler_class_done(i); continue; } } } else if (active_crawler_mod.mod->needs_client) { lru_crawler_class_done(i); continue; } pthread_mutex_lock(&lru_locks[i]); search = do_item_crawl_q((item *)&crawlers[i]); if (search == NULL || (crawlers[i].remaining && --crawlers[i].remaining < 1)) { if (settings.verbose > 2) fprintf(stderr, "Nothing left to crawl for %d\n", i); lru_crawler_class_done(i); continue; } uint32_t hv = hash(ITEM_key(search), search->nkey); /* Attempt to hash item lock the "search" item. If locked, no * other callers can incr the refcount */ if ((hold_lock = item_trylock(hv)) == NULL) { pthread_mutex_unlock(&lru_locks[i]); continue; } /* Now see if the item is refcount locked */ if (refcount_incr(search) != 2) { refcount_decr(search); if (hold_lock) item_trylock_unlock(hold_lock); pthread_mutex_unlock(&lru_locks[i]); continue; } crawlers[i].checked++; /* Frees the item or decrements the refcount. */ /* Interface for this could improve: do the free/decr here * instead? */ if (!active_crawler_mod.mod->needs_lock) { pthread_mutex_unlock(&lru_locks[i]); } active_crawler_mod.mod->eval(&active_crawler_mod, search, hv, i); if (hold_lock) item_trylock_unlock(hold_lock); if (active_crawler_mod.mod->needs_lock) { pthread_mutex_unlock(&lru_locks[i]); } if (crawls_persleep-- <= 0 && settings.lru_crawler_sleep) { pthread_mutex_unlock(&lru_crawler_lock); usleep(settings.lru_crawler_sleep); pthread_mutex_lock(&lru_crawler_lock); crawls_persleep = settings.crawls_persleep; } else if (!settings.lru_crawler_sleep) { // TODO: only cycle lock every N? pthread_mutex_unlock(&lru_crawler_lock); pthread_mutex_lock(&lru_crawler_lock); } } } // while } // if crawler_count if (active_crawler_mod.mod != NULL) { if (active_crawler_mod.mod->finalize != NULL) active_crawler_mod.mod->finalize(&active_crawler_mod); while (active_crawler_mod.c.c != NULL && active_crawler_mod.c.bufused != 0) { lru_crawler_write(&active_crawler_mod.c); } // Double checking in case the client closed during the poll if (active_crawler_mod.c.c != NULL) { lru_crawler_release_client(&active_crawler_mod.c); } active_crawler_mod.mod = NULL; } if (settings.verbose > 2) fprintf(stderr, "LRU crawler thread sleeping\n"); STATS_LOCK(); stats_state.lru_crawler_running = false; STATS_UNLOCK(); } pthread_mutex_unlock(&lru_crawler_lock); if (settings.verbose > 2) fprintf(stderr, "LRU crawler thread stopping\n"); settings.lru_crawler = false; return NULL; } static pthread_t item_crawler_tid; int stop_item_crawler_thread(bool wait) { int ret; pthread_mutex_lock(&lru_crawler_lock); if (do_run_lru_crawler_thread == 0) { pthread_mutex_unlock(&lru_crawler_lock); return 0; } do_run_lru_crawler_thread = 0; pthread_cond_signal(&lru_crawler_cond); pthread_mutex_unlock(&lru_crawler_lock); if (wait && (ret = pthread_join(item_crawler_tid, NULL)) != 0) { fprintf(stderr, "Failed to stop LRU crawler thread: %s\n", strerror(ret)); return -1; } return 0; } /* Lock dance to "block" until thread is waiting on its condition: * caller locks mtx. caller spawns thread. * thread blocks on mutex. * caller waits on condition, releases lock. * thread gets lock, sends signal. * caller can't wait, as thread has lock. * thread waits on condition, releases lock * caller wakes on condition, gets lock. * caller immediately releases lock. * thread is now safely waiting on condition before the caller returns. */ int start_item_crawler_thread(void) { int ret; if (settings.lru_crawler) return -1; pthread_mutex_lock(&lru_crawler_lock); do_run_lru_crawler_thread = 1; if ((ret = pthread_create(&item_crawler_tid, NULL, item_crawler_thread, NULL)) != 0) { fprintf(stderr, "Can't create LRU crawler thread: %s\n", strerror(ret)); pthread_mutex_unlock(&lru_crawler_lock); return -1; } thread_setname(item_crawler_tid, "mc-itemcrawler"); /* Avoid returning until the crawler has actually started */ pthread_cond_wait(&lru_crawler_cond, &lru_crawler_lock); pthread_mutex_unlock(&lru_crawler_lock); return 0; } /* 'remaining' is passed in so the LRU maintainer thread can scrub the whole * LRU every time. */ static int do_lru_crawler_start(uint32_t id, uint32_t remaining) { uint32_t sid = id; int starts = 0; pthread_mutex_lock(&lru_locks[sid]); if (crawlers[sid].it_flags == 0) { if (settings.verbose > 2) fprintf(stderr, "Kicking LRU crawler off for LRU %u\n", sid); crawlers[sid].nbytes = 0; crawlers[sid].nkey = 0; crawlers[sid].it_flags = 1; /* For a crawler, this means enabled. */ crawlers[sid].next = 0; crawlers[sid].prev = 0; crawlers[sid].time = 0; if (remaining == LRU_CRAWLER_CAP_REMAINING) { remaining = do_get_lru_size(sid); } /* Values for remaining: * remaining = 0 * - scan all elements, until a NULL is reached * - if empty, NULL is reached right away * remaining = n + 1 * - first n elements are parsed (or until a NULL is reached) */ if (remaining) remaining++; crawlers[sid].remaining = remaining; crawlers[sid].slabs_clsid = sid; crawlers[sid].reclaimed = 0; crawlers[sid].unfetched = 0; crawlers[sid].checked = 0; do_item_linktail_q((item *)&crawlers[sid]); crawler_count++; starts++; } pthread_mutex_unlock(&lru_locks[sid]); return starts; } static int lru_crawler_set_client(crawler_module_t *cm, void *c, const int sfd) { crawler_client_t *crawlc = &cm->c; if (crawlc->c != NULL) { return -1; } crawlc->c = c; crawlc->sfd = sfd; size_t size = LRU_CRAWLER_MINBUFSPACE * 16; crawlc->buf = malloc(size); if (crawlc->buf == NULL) { return -2; } crawlc->buflen = size; crawlc->bufused = 0; return 0; } int lru_crawler_start(uint8_t *ids, uint32_t remaining, const enum crawler_run_type type, void *data, void *c, const int sfd) { int starts = 0; bool is_running; static rel_time_t block_ae_until = 0; pthread_mutex_lock(&lru_crawler_lock); STATS_LOCK(); is_running = stats_state.lru_crawler_running; STATS_UNLOCK(); if (do_run_lru_crawler_thread == 0) { pthread_mutex_unlock(&lru_crawler_lock); return -2; } if (is_running && !(type == CRAWLER_AUTOEXPIRE && active_crawler_type == CRAWLER_AUTOEXPIRE)) { pthread_mutex_unlock(&lru_crawler_lock); block_ae_until = current_time + 60; return -1; } if (type == CRAWLER_AUTOEXPIRE && block_ae_until > current_time) { pthread_mutex_unlock(&lru_crawler_lock); return -1; } /* hash table walk only supported with metadump for now. */ if (ids == NULL && type != CRAWLER_METADUMP && type != CRAWLER_MGDUMP) { pthread_mutex_unlock(&lru_crawler_lock); return -2; } /* Configure the module */ if (!is_running) { assert(crawler_mod_regs[type] != NULL); active_crawler_mod.mod = crawler_mod_regs[type]; active_crawler_type = type; if (active_crawler_mod.mod->init != NULL) { active_crawler_mod.mod->init(&active_crawler_mod, data); } if (active_crawler_mod.mod->needs_client) { if (c == NULL || sfd == 0) { pthread_mutex_unlock(&lru_crawler_lock); return -2; } if (lru_crawler_set_client(&active_crawler_mod, c, sfd) != 0) { pthread_mutex_unlock(&lru_crawler_lock); return -2; } } } if (ids == NULL) { /* NULL ids means to walk the hash table instead. */ starts = 1; /* FIXME: hack to signal hash mode to the crawler thread. * Something more clear would be nice. */ crawler_count = -1; } else { /* we allow the autocrawler to restart sub-LRU's before completion */ for (int sid = POWER_SMALLEST; sid < POWER_LARGEST; sid++) { if (ids[sid]) starts += do_lru_crawler_start(sid, remaining); } } if (starts) { STATS_LOCK(); stats_state.lru_crawler_running = true; stats.lru_crawler_starts++; STATS_UNLOCK(); pthread_cond_signal(&lru_crawler_cond); } pthread_mutex_unlock(&lru_crawler_lock); return starts; } /* * Also only clear the crawlerstats once per sid. */ enum crawler_result_type lru_crawler_crawl(char *slabs, const enum crawler_run_type type, void *c, const int sfd, unsigned int remaining) { char *b = NULL; uint32_t sid = 0; int starts = 0; uint8_t tocrawl[POWER_LARGEST]; bool hash_crawl = false; /* FIXME: I added this while debugging. Don't think it's needed? */ memset(tocrawl, 0, sizeof(uint8_t) * POWER_LARGEST); if (strcmp(slabs, "all") == 0) { for (sid = 0; sid < POWER_LARGEST; sid++) { tocrawl[sid] = 1; } } else if (strcmp(slabs, "hash") == 0) { hash_crawl = true; } else { for (char *p = strtok_r(slabs, ",", &b); p != NULL; p = strtok_r(NULL, ",", &b)) { if (!safe_strtoul(p, &sid) || sid < POWER_SMALLEST || sid >= MAX_NUMBER_OF_SLAB_CLASSES) { return CRAWLER_BADCLASS; } tocrawl[sid | TEMP_LRU] = 1; tocrawl[sid | HOT_LRU] = 1; tocrawl[sid | WARM_LRU] = 1; tocrawl[sid | COLD_LRU] = 1; } } starts = lru_crawler_start(hash_crawl ? NULL : tocrawl, remaining, type, NULL, c, sfd); if (starts == -1) { return CRAWLER_RUNNING; } else if (starts == -2) { return CRAWLER_ERROR; /* FIXME: not very helpful. */ } else if (starts) { return CRAWLER_OK; } else { return CRAWLER_NOTSTARTED; } } /* If we hold this lock, crawler can't wake up or move */ void lru_crawler_pause(void) { pthread_mutex_lock(&lru_crawler_lock); } void lru_crawler_resume(void) { pthread_mutex_unlock(&lru_crawler_lock); } int init_lru_crawler(void *arg) { if (lru_crawler_initialized == 0) { #ifdef EXTSTORE storage = arg; #endif active_crawler_mod.c.c = NULL; active_crawler_mod.mod = NULL; active_crawler_mod.data = NULL; lru_crawler_initialized = 1; } return 0; } memcached-1.6.20/config.sub0000755000175000017500000010511614175772605012434 00000000000000#! /bin/sh # Configuration validation subroutine script. # Copyright 1992-2022 Free Software Foundation, Inc. # shellcheck disable=SC2006,SC2268 # see below for rationale timestamp='2022-01-03' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that # program. This Exception is an additional permission under section 7 # of the GNU General Public License, version 3 ("GPLv3"). # Please send patches to . # # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. # If it is invalid, we print an error message on stderr and exit with code 1. # Otherwise, we print the canonical config type on stdout and succeed. # You can get the latest version of this script from: # https://git.savannah.gnu.org/cgit/config.git/plain/config.sub # This file is supposed to be the same for all GNU packages # and recognize all the CPU types, system types and aliases # that are meaningful with *any* GNU software. # Each package is responsible for reporting which valid configurations # it does not support. The user should be able to distinguish # a failure to support a valid configuration from a meaningless # configuration. # The goal of this file is to map all the various variations of a given # machine specification into a single specification in the form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or in some cases, the newer four-part form: # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # It is wrong to echo any other type of specification. # The "shellcheck disable" line above the timestamp inhibits complaints # about features and limitations of the classic Bourne shell that were # superseded or lifted in POSIX. However, this script identifies a wide # variety of pre-POSIX systems that do not have POSIX shells at all, and # even some reasonably current systems (Solaris 10 as case-in-point) still # have a pre-POSIX /bin/sh. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS Canonicalize a configuration name. Options: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.sub ($timestamp) Copyright 1992-2022 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; *local*) # First pass through any local machine types. echo "$1" exit ;; * ) break ;; esac done case $# in 0) echo "$me: missing argument$help" >&2 exit 1;; 1) ;; *) echo "$me: too many arguments$help" >&2 exit 1;; esac # Split fields of configuration type # shellcheck disable=SC2162 saved_IFS=$IFS IFS="-" read field1 field2 field3 field4 <&2 exit 1 ;; *-*-*-*) basic_machine=$field1-$field2 basic_os=$field3-$field4 ;; *-*-*) # Ambiguous whether COMPANY is present, or skipped and KERNEL-OS is two # parts maybe_os=$field2-$field3 case $maybe_os in nto-qnx* | linux-* | uclinux-uclibc* \ | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* \ | netbsd*-eabi* | kopensolaris*-gnu* | cloudabi*-eabi* \ | storm-chaos* | os2-emx* | rtmk-nova*) basic_machine=$field1 basic_os=$maybe_os ;; android-linux) basic_machine=$field1-unknown basic_os=linux-android ;; *) basic_machine=$field1-$field2 basic_os=$field3 ;; esac ;; *-*) # A lone config we happen to match not fitting any pattern case $field1-$field2 in decstation-3100) basic_machine=mips-dec basic_os= ;; *-*) # Second component is usually, but not always the OS case $field2 in # Prevent following clause from handling this valid os sun*os*) basic_machine=$field1 basic_os=$field2 ;; zephyr*) basic_machine=$field1-unknown basic_os=$field2 ;; # Manufacturers dec* | mips* | sequent* | encore* | pc533* | sgi* | sony* \ | att* | 7300* | 3300* | delta* | motorola* | sun[234]* \ | unicom* | ibm* | next | hp | isi* | apollo | altos* \ | convergent* | ncr* | news | 32* | 3600* | 3100* \ | hitachi* | c[123]* | convex* | sun | crds | omron* | dg \ | ultra | tti* | harris | dolphin | highlevel | gould \ | cbm | ns | masscomp | apple | axis | knuth | cray \ | microblaze* | sim | cisco \ | oki | wec | wrs | winbond) basic_machine=$field1-$field2 basic_os= ;; *) basic_machine=$field1 basic_os=$field2 ;; esac ;; esac ;; *) # Convert single-component short-hands not valid as part of # multi-component configurations. case $field1 in 386bsd) basic_machine=i386-pc basic_os=bsd ;; a29khif) basic_machine=a29k-amd basic_os=udi ;; adobe68k) basic_machine=m68010-adobe basic_os=scout ;; alliant) basic_machine=fx80-alliant basic_os= ;; altos | altos3068) basic_machine=m68k-altos basic_os= ;; am29k) basic_machine=a29k-none basic_os=bsd ;; amdahl) basic_machine=580-amdahl basic_os=sysv ;; amiga) basic_machine=m68k-unknown basic_os= ;; amigaos | amigados) basic_machine=m68k-unknown basic_os=amigaos ;; amigaunix | amix) basic_machine=m68k-unknown basic_os=sysv4 ;; apollo68) basic_machine=m68k-apollo basic_os=sysv ;; apollo68bsd) basic_machine=m68k-apollo basic_os=bsd ;; aros) basic_machine=i386-pc basic_os=aros ;; aux) basic_machine=m68k-apple basic_os=aux ;; balance) basic_machine=ns32k-sequent basic_os=dynix ;; blackfin) basic_machine=bfin-unknown basic_os=linux ;; cegcc) basic_machine=arm-unknown basic_os=cegcc ;; convex-c1) basic_machine=c1-convex basic_os=bsd ;; convex-c2) basic_machine=c2-convex basic_os=bsd ;; convex-c32) basic_machine=c32-convex basic_os=bsd ;; convex-c34) basic_machine=c34-convex basic_os=bsd ;; convex-c38) basic_machine=c38-convex basic_os=bsd ;; cray) basic_machine=j90-cray basic_os=unicos ;; crds | unos) basic_machine=m68k-crds basic_os= ;; da30) basic_machine=m68k-da30 basic_os= ;; decstation | pmax | pmin | dec3100 | decstatn) basic_machine=mips-dec basic_os= ;; delta88) basic_machine=m88k-motorola basic_os=sysv3 ;; dicos) basic_machine=i686-pc basic_os=dicos ;; djgpp) basic_machine=i586-pc basic_os=msdosdjgpp ;; ebmon29k) basic_machine=a29k-amd basic_os=ebmon ;; es1800 | OSE68k | ose68k | ose | OSE) basic_machine=m68k-ericsson basic_os=ose ;; gmicro) basic_machine=tron-gmicro basic_os=sysv ;; go32) basic_machine=i386-pc basic_os=go32 ;; h8300hms) basic_machine=h8300-hitachi basic_os=hms ;; h8300xray) basic_machine=h8300-hitachi basic_os=xray ;; h8500hms) basic_machine=h8500-hitachi basic_os=hms ;; harris) basic_machine=m88k-harris basic_os=sysv3 ;; hp300 | hp300hpux) basic_machine=m68k-hp basic_os=hpux ;; hp300bsd) basic_machine=m68k-hp basic_os=bsd ;; hppaosf) basic_machine=hppa1.1-hp basic_os=osf ;; hppro) basic_machine=hppa1.1-hp basic_os=proelf ;; i386mach) basic_machine=i386-mach basic_os=mach ;; isi68 | isi) basic_machine=m68k-isi basic_os=sysv ;; m68knommu) basic_machine=m68k-unknown basic_os=linux ;; magnum | m3230) basic_machine=mips-mips basic_os=sysv ;; merlin) basic_machine=ns32k-utek basic_os=sysv ;; mingw64) basic_machine=x86_64-pc basic_os=mingw64 ;; mingw32) basic_machine=i686-pc basic_os=mingw32 ;; mingw32ce) basic_machine=arm-unknown basic_os=mingw32ce ;; monitor) basic_machine=m68k-rom68k basic_os=coff ;; morphos) basic_machine=powerpc-unknown basic_os=morphos ;; moxiebox) basic_machine=moxie-unknown basic_os=moxiebox ;; msdos) basic_machine=i386-pc basic_os=msdos ;; msys) basic_machine=i686-pc basic_os=msys ;; mvs) basic_machine=i370-ibm basic_os=mvs ;; nacl) basic_machine=le32-unknown basic_os=nacl ;; ncr3000) basic_machine=i486-ncr basic_os=sysv4 ;; netbsd386) basic_machine=i386-pc basic_os=netbsd ;; netwinder) basic_machine=armv4l-rebel basic_os=linux ;; news | news700 | news800 | news900) basic_machine=m68k-sony basic_os=newsos ;; news1000) basic_machine=m68030-sony basic_os=newsos ;; necv70) basic_machine=v70-nec basic_os=sysv ;; nh3000) basic_machine=m68k-harris basic_os=cxux ;; nh[45]000) basic_machine=m88k-harris basic_os=cxux ;; nindy960) basic_machine=i960-intel basic_os=nindy ;; mon960) basic_machine=i960-intel basic_os=mon960 ;; nonstopux) basic_machine=mips-compaq basic_os=nonstopux ;; os400) basic_machine=powerpc-ibm basic_os=os400 ;; OSE68000 | ose68000) basic_machine=m68000-ericsson basic_os=ose ;; os68k) basic_machine=m68k-none basic_os=os68k ;; paragon) basic_machine=i860-intel basic_os=osf ;; parisc) basic_machine=hppa-unknown basic_os=linux ;; psp) basic_machine=mipsallegrexel-sony basic_os=psp ;; pw32) basic_machine=i586-unknown basic_os=pw32 ;; rdos | rdos64) basic_machine=x86_64-pc basic_os=rdos ;; rdos32) basic_machine=i386-pc basic_os=rdos ;; rom68k) basic_machine=m68k-rom68k basic_os=coff ;; sa29200) basic_machine=a29k-amd basic_os=udi ;; sei) basic_machine=mips-sei basic_os=seiux ;; sequent) basic_machine=i386-sequent basic_os= ;; sps7) basic_machine=m68k-bull basic_os=sysv2 ;; st2000) basic_machine=m68k-tandem basic_os= ;; stratus) basic_machine=i860-stratus basic_os=sysv4 ;; sun2) basic_machine=m68000-sun basic_os= ;; sun2os3) basic_machine=m68000-sun basic_os=sunos3 ;; sun2os4) basic_machine=m68000-sun basic_os=sunos4 ;; sun3) basic_machine=m68k-sun basic_os= ;; sun3os3) basic_machine=m68k-sun basic_os=sunos3 ;; sun3os4) basic_machine=m68k-sun basic_os=sunos4 ;; sun4) basic_machine=sparc-sun basic_os= ;; sun4os3) basic_machine=sparc-sun basic_os=sunos3 ;; sun4os4) basic_machine=sparc-sun basic_os=sunos4 ;; sun4sol2) basic_machine=sparc-sun basic_os=solaris2 ;; sun386 | sun386i | roadrunner) basic_machine=i386-sun basic_os= ;; sv1) basic_machine=sv1-cray basic_os=unicos ;; symmetry) basic_machine=i386-sequent basic_os=dynix ;; t3e) basic_machine=alphaev5-cray basic_os=unicos ;; t90) basic_machine=t90-cray basic_os=unicos ;; toad1) basic_machine=pdp10-xkl basic_os=tops20 ;; tpf) basic_machine=s390x-ibm basic_os=tpf ;; udi29k) basic_machine=a29k-amd basic_os=udi ;; ultra3) basic_machine=a29k-nyu basic_os=sym1 ;; v810 | necv810) basic_machine=v810-nec basic_os=none ;; vaxv) basic_machine=vax-dec basic_os=sysv ;; vms) basic_machine=vax-dec basic_os=vms ;; vsta) basic_machine=i386-pc basic_os=vsta ;; vxworks960) basic_machine=i960-wrs basic_os=vxworks ;; vxworks68) basic_machine=m68k-wrs basic_os=vxworks ;; vxworks29k) basic_machine=a29k-wrs basic_os=vxworks ;; xbox) basic_machine=i686-pc basic_os=mingw32 ;; ymp) basic_machine=ymp-cray basic_os=unicos ;; *) basic_machine=$1 basic_os= ;; esac ;; esac # Decode 1-component or ad-hoc basic machines case $basic_machine in # Here we handle the default manufacturer of certain CPU types. It is in # some cases the only manufacturer, in others, it is the most popular. w89k) cpu=hppa1.1 vendor=winbond ;; op50n) cpu=hppa1.1 vendor=oki ;; op60c) cpu=hppa1.1 vendor=oki ;; ibm*) cpu=i370 vendor=ibm ;; orion105) cpu=clipper vendor=highlevel ;; mac | mpw | mac-mpw) cpu=m68k vendor=apple ;; pmac | pmac-mpw) cpu=powerpc vendor=apple ;; # Recognize the various machine names and aliases which stand # for a CPU type and a company and sometimes even an OS. 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) cpu=m68000 vendor=att ;; 3b*) cpu=we32k vendor=att ;; bluegene*) cpu=powerpc vendor=ibm basic_os=cnk ;; decsystem10* | dec10*) cpu=pdp10 vendor=dec basic_os=tops10 ;; decsystem20* | dec20*) cpu=pdp10 vendor=dec basic_os=tops20 ;; delta | 3300 | motorola-3300 | motorola-delta \ | 3300-motorola | delta-motorola) cpu=m68k vendor=motorola ;; dpx2*) cpu=m68k vendor=bull basic_os=sysv3 ;; encore | umax | mmax) cpu=ns32k vendor=encore ;; elxsi) cpu=elxsi vendor=elxsi basic_os=${basic_os:-bsd} ;; fx2800) cpu=i860 vendor=alliant ;; genix) cpu=ns32k vendor=ns ;; h3050r* | hiux*) cpu=hppa1.1 vendor=hitachi basic_os=hiuxwe2 ;; hp3k9[0-9][0-9] | hp9[0-9][0-9]) cpu=hppa1.0 vendor=hp ;; hp9k2[0-9][0-9] | hp9k31[0-9]) cpu=m68000 vendor=hp ;; hp9k3[2-9][0-9]) cpu=m68k vendor=hp ;; hp9k6[0-9][0-9] | hp6[0-9][0-9]) cpu=hppa1.0 vendor=hp ;; hp9k7[0-79][0-9] | hp7[0-79][0-9]) cpu=hppa1.1 vendor=hp ;; hp9k78[0-9] | hp78[0-9]) # FIXME: really hppa2.0-hp cpu=hppa1.1 vendor=hp ;; hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) # FIXME: really hppa2.0-hp cpu=hppa1.1 vendor=hp ;; hp9k8[0-9][13679] | hp8[0-9][13679]) cpu=hppa1.1 vendor=hp ;; hp9k8[0-9][0-9] | hp8[0-9][0-9]) cpu=hppa1.0 vendor=hp ;; i*86v32) cpu=`echo "$1" | sed -e 's/86.*/86/'` vendor=pc basic_os=sysv32 ;; i*86v4*) cpu=`echo "$1" | sed -e 's/86.*/86/'` vendor=pc basic_os=sysv4 ;; i*86v) cpu=`echo "$1" | sed -e 's/86.*/86/'` vendor=pc basic_os=sysv ;; i*86sol2) cpu=`echo "$1" | sed -e 's/86.*/86/'` vendor=pc basic_os=solaris2 ;; j90 | j90-cray) cpu=j90 vendor=cray basic_os=${basic_os:-unicos} ;; iris | iris4d) cpu=mips vendor=sgi case $basic_os in irix*) ;; *) basic_os=irix4 ;; esac ;; miniframe) cpu=m68000 vendor=convergent ;; *mint | mint[0-9]* | *MiNT | *MiNT[0-9]*) cpu=m68k vendor=atari basic_os=mint ;; news-3600 | risc-news) cpu=mips vendor=sony basic_os=newsos ;; next | m*-next) cpu=m68k vendor=next case $basic_os in openstep*) ;; nextstep*) ;; ns2*) basic_os=nextstep2 ;; *) basic_os=nextstep3 ;; esac ;; np1) cpu=np1 vendor=gould ;; op50n-* | op60c-*) cpu=hppa1.1 vendor=oki basic_os=proelf ;; pa-hitachi) cpu=hppa1.1 vendor=hitachi basic_os=hiuxwe2 ;; pbd) cpu=sparc vendor=tti ;; pbb) cpu=m68k vendor=tti ;; pc532) cpu=ns32k vendor=pc532 ;; pn) cpu=pn vendor=gould ;; power) cpu=power vendor=ibm ;; ps2) cpu=i386 vendor=ibm ;; rm[46]00) cpu=mips vendor=siemens ;; rtpc | rtpc-*) cpu=romp vendor=ibm ;; sde) cpu=mipsisa32 vendor=sde basic_os=${basic_os:-elf} ;; simso-wrs) cpu=sparclite vendor=wrs basic_os=vxworks ;; tower | tower-32) cpu=m68k vendor=ncr ;; vpp*|vx|vx-*) cpu=f301 vendor=fujitsu ;; w65) cpu=w65 vendor=wdc ;; w89k-*) cpu=hppa1.1 vendor=winbond basic_os=proelf ;; none) cpu=none vendor=none ;; leon|leon[3-9]) cpu=sparc vendor=$basic_machine ;; leon-*|leon[3-9]-*) cpu=sparc vendor=`echo "$basic_machine" | sed 's/-.*//'` ;; *-*) # shellcheck disable=SC2162 saved_IFS=$IFS IFS="-" read cpu vendor <&2 exit 1 ;; esac ;; esac # Here we canonicalize certain aliases for manufacturers. case $vendor in digital*) vendor=dec ;; commodore*) vendor=cbm ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. if test x$basic_os != x then # First recognize some ad-hoc cases, or perhaps split kernel-os, or else just # set os. case $basic_os in gnu/linux*) kernel=linux os=`echo "$basic_os" | sed -e 's|gnu/linux|gnu|'` ;; os2-emx) kernel=os2 os=`echo "$basic_os" | sed -e 's|os2-emx|emx|'` ;; nto-qnx*) kernel=nto os=`echo "$basic_os" | sed -e 's|nto-qnx|qnx|'` ;; *-*) # shellcheck disable=SC2162 saved_IFS=$IFS IFS="-" read kernel os <&2 exit 1 ;; esac # As a final step for OS-related things, validate the OS-kernel combination # (given a valid OS), if there is a kernel. case $kernel-$os in linux-gnu* | linux-dietlibc* | linux-android* | linux-newlib* \ | linux-musl* | linux-relibc* | linux-uclibc* ) ;; uclinux-uclibc* ) ;; -dietlibc* | -newlib* | -musl* | -relibc* | -uclibc* ) # These are just libc implementations, not actual OSes, and thus # require a kernel. echo "Invalid configuration \`$1': libc \`$os' needs explicit kernel." 1>&2 exit 1 ;; kfreebsd*-gnu* | kopensolaris*-gnu*) ;; vxworks-simlinux | vxworks-simwindows | vxworks-spe) ;; nto-qnx*) ;; os2-emx) ;; *-eabi* | *-gnueabi*) ;; -*) # Blank kernel with real OS is always fine. ;; *-*) echo "Invalid configuration \`$1': Kernel \`$kernel' not known to work with OS \`$os'." 1>&2 exit 1 ;; esac # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. case $vendor in unknown) case $cpu-$os in *-riscix*) vendor=acorn ;; *-sunos*) vendor=sun ;; *-cnk* | *-aix*) vendor=ibm ;; *-beos*) vendor=be ;; *-hpux*) vendor=hp ;; *-mpeix*) vendor=hp ;; *-hiux*) vendor=hitachi ;; *-unos*) vendor=crds ;; *-dgux*) vendor=dg ;; *-luna*) vendor=omron ;; *-genix*) vendor=ns ;; *-clix*) vendor=intergraph ;; *-mvs* | *-opened*) vendor=ibm ;; *-os400*) vendor=ibm ;; s390-* | s390x-*) vendor=ibm ;; *-ptx*) vendor=sequent ;; *-tpf*) vendor=ibm ;; *-vxsim* | *-vxworks* | *-windiss*) vendor=wrs ;; *-aux*) vendor=apple ;; *-hms*) vendor=hitachi ;; *-mpw* | *-macos*) vendor=apple ;; *-*mint | *-mint[0-9]* | *-*MiNT | *-MiNT[0-9]*) vendor=atari ;; *-vos*) vendor=stratus ;; esac ;; esac echo "$cpu-$vendor-${kernel:+$kernel-}$os" exit # Local variables: # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: memcached-1.6.20/protocol_binary.h0000664000175000017500000004021513704126374014020 00000000000000/* * Copyright (c) <2008>, Sun Microsystems, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the nor the * names of its contributors may be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY SUN MICROSYSTEMS, INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL SUN MICROSYSTEMS, INC. BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * Summary: Constants used by to implement the binary protocol. * * Copy: See Copyright for the status of this software. * * Author: Trond Norbye */ #ifndef PROTOCOL_BINARY_H #define PROTOCOL_BINARY_H /** * This file contains definitions of the constants and packet formats * defined in the binary specification. Please note that you _MUST_ remember * to convert each multibyte field to / from network byte order to / from * host order. */ #ifdef __cplusplus extern "C" { #endif /** * Definition of the legal "magic" values used in a packet. * See section 3.1 Magic byte */ typedef enum { PROTOCOL_BINARY_REQ = 0x80, PROTOCOL_BINARY_RES = 0x81 } protocol_binary_magic; /** * Definition of the valid response status numbers. * See section 3.2 Response Status */ typedef enum { PROTOCOL_BINARY_RESPONSE_SUCCESS = 0x00, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT = 0x01, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS = 0x02, PROTOCOL_BINARY_RESPONSE_E2BIG = 0x03, PROTOCOL_BINARY_RESPONSE_EINVAL = 0x04, PROTOCOL_BINARY_RESPONSE_NOT_STORED = 0x05, PROTOCOL_BINARY_RESPONSE_DELTA_BADVAL = 0x06, PROTOCOL_BINARY_RESPONSE_AUTH_ERROR = 0x20, PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE = 0x21, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND = 0x81, PROTOCOL_BINARY_RESPONSE_ENOMEM = 0x82 } protocol_binary_response_status; /** * Definition of the different command opcodes. * See section 3.3 Command Opcodes */ typedef enum { PROTOCOL_BINARY_CMD_GET = 0x00, PROTOCOL_BINARY_CMD_SET = 0x01, PROTOCOL_BINARY_CMD_ADD = 0x02, PROTOCOL_BINARY_CMD_REPLACE = 0x03, PROTOCOL_BINARY_CMD_DELETE = 0x04, PROTOCOL_BINARY_CMD_INCREMENT = 0x05, PROTOCOL_BINARY_CMD_DECREMENT = 0x06, PROTOCOL_BINARY_CMD_QUIT = 0x07, PROTOCOL_BINARY_CMD_FLUSH = 0x08, PROTOCOL_BINARY_CMD_GETQ = 0x09, PROTOCOL_BINARY_CMD_NOOP = 0x0a, PROTOCOL_BINARY_CMD_VERSION = 0x0b, PROTOCOL_BINARY_CMD_GETK = 0x0c, PROTOCOL_BINARY_CMD_GETKQ = 0x0d, PROTOCOL_BINARY_CMD_APPEND = 0x0e, PROTOCOL_BINARY_CMD_PREPEND = 0x0f, PROTOCOL_BINARY_CMD_STAT = 0x10, PROTOCOL_BINARY_CMD_SETQ = 0x11, PROTOCOL_BINARY_CMD_ADDQ = 0x12, PROTOCOL_BINARY_CMD_REPLACEQ = 0x13, PROTOCOL_BINARY_CMD_DELETEQ = 0x14, PROTOCOL_BINARY_CMD_INCREMENTQ = 0x15, PROTOCOL_BINARY_CMD_DECREMENTQ = 0x16, PROTOCOL_BINARY_CMD_QUITQ = 0x17, PROTOCOL_BINARY_CMD_FLUSHQ = 0x18, PROTOCOL_BINARY_CMD_APPENDQ = 0x19, PROTOCOL_BINARY_CMD_PREPENDQ = 0x1a, PROTOCOL_BINARY_CMD_TOUCH = 0x1c, PROTOCOL_BINARY_CMD_GAT = 0x1d, PROTOCOL_BINARY_CMD_GATQ = 0x1e, PROTOCOL_BINARY_CMD_GATK = 0x23, PROTOCOL_BINARY_CMD_GATKQ = 0x24, PROTOCOL_BINARY_CMD_SASL_LIST_MECHS = 0x20, PROTOCOL_BINARY_CMD_SASL_AUTH = 0x21, PROTOCOL_BINARY_CMD_SASL_STEP = 0x22, /* These commands are used for range operations and exist within * this header for use in other projects. Range operations are * not expected to be implemented in the memcached server itself. */ PROTOCOL_BINARY_CMD_RGET = 0x30, PROTOCOL_BINARY_CMD_RSET = 0x31, PROTOCOL_BINARY_CMD_RSETQ = 0x32, PROTOCOL_BINARY_CMD_RAPPEND = 0x33, PROTOCOL_BINARY_CMD_RAPPENDQ = 0x34, PROTOCOL_BINARY_CMD_RPREPEND = 0x35, PROTOCOL_BINARY_CMD_RPREPENDQ = 0x36, PROTOCOL_BINARY_CMD_RDELETE = 0x37, PROTOCOL_BINARY_CMD_RDELETEQ = 0x38, PROTOCOL_BINARY_CMD_RINCR = 0x39, PROTOCOL_BINARY_CMD_RINCRQ = 0x3a, PROTOCOL_BINARY_CMD_RDECR = 0x3b, PROTOCOL_BINARY_CMD_RDECRQ = 0x3c /* End Range operations */ } protocol_binary_command; /** * Definition of the data types in the packet * See section 3.4 Data Types */ typedef enum { PROTOCOL_BINARY_RAW_BYTES = 0x00 } protocol_binary_datatypes; /** * Definition of the header structure for a request packet. * See section 2 */ typedef union { struct { uint8_t magic; uint8_t opcode; uint16_t keylen; uint8_t extlen; uint8_t datatype; uint16_t reserved; uint32_t bodylen; uint32_t opaque; uint64_t cas; } request; uint8_t bytes[24]; } protocol_binary_request_header; /** * Definition of the header structure for a response packet. * See section 2 */ typedef union { struct { uint8_t magic; uint8_t opcode; uint16_t keylen; uint8_t extlen; uint8_t datatype; uint16_t status; uint32_t bodylen; uint32_t opaque; uint64_t cas; } response; uint8_t bytes[24]; } protocol_binary_response_header; /** * Definition of a request-packet containing no extras */ typedef union { struct { protocol_binary_request_header header; } message; uint8_t bytes[sizeof(protocol_binary_request_header)]; } protocol_binary_request_no_extras; /** * Definition of a response-packet containing no extras */ typedef union { struct { protocol_binary_response_header header; } message; uint8_t bytes[sizeof(protocol_binary_response_header)]; } protocol_binary_response_no_extras; /** * Definition of the packet used by the get, getq, getk and getkq command. * See section 4 */ typedef protocol_binary_request_no_extras protocol_binary_request_get; typedef protocol_binary_request_no_extras protocol_binary_request_getq; typedef protocol_binary_request_no_extras protocol_binary_request_getk; typedef protocol_binary_request_no_extras protocol_binary_request_getkq; /** * Definition of the packet returned from a successful get, getq, getk and * getkq. * See section 4 */ typedef union { struct { protocol_binary_response_header header; struct { uint32_t flags; } body; } message; uint8_t bytes[sizeof(protocol_binary_response_header) + 4]; } protocol_binary_response_get; typedef protocol_binary_response_get protocol_binary_response_getq; typedef protocol_binary_response_get protocol_binary_response_getk; typedef protocol_binary_response_get protocol_binary_response_getkq; /** * Definition of the packet used by the delete command * See section 4 */ typedef protocol_binary_request_no_extras protocol_binary_request_delete; /** * Definition of the packet returned by the delete command * See section 4 */ typedef protocol_binary_response_no_extras protocol_binary_response_delete; /** * Definition of the packet used by the flush command * See section 4 * Please note that the expiration field is optional, so remember to see * check the header.bodysize to see if it is present. */ typedef union { struct { protocol_binary_request_header header; struct { uint32_t expiration; } body; } message; uint8_t bytes[sizeof(protocol_binary_request_header) + 4]; } protocol_binary_request_flush; /** * Definition of the packet returned by the flush command * See section 4 */ typedef protocol_binary_response_no_extras protocol_binary_response_flush; /** * Definition of the packet used by set, add and replace * See section 4 */ typedef union { struct { protocol_binary_request_header header; struct { uint32_t flags; uint32_t expiration; } body; } message; uint8_t bytes[sizeof(protocol_binary_request_header) + 8]; } protocol_binary_request_set; typedef protocol_binary_request_set protocol_binary_request_add; typedef protocol_binary_request_set protocol_binary_request_replace; /** * Definition of the packet returned by set, add and replace * See section 4 */ typedef protocol_binary_response_no_extras protocol_binary_response_set; typedef protocol_binary_response_no_extras protocol_binary_response_add; typedef protocol_binary_response_no_extras protocol_binary_response_replace; /** * Definition of the noop packet * See section 4 */ typedef protocol_binary_request_no_extras protocol_binary_request_noop; /** * Definition of the packet returned by the noop command * See section 4 */ typedef protocol_binary_response_no_extras protocol_binary_response_noop; /** * Definition of the structure used by the increment and decrement * command. * See section 4 */ typedef union { struct { protocol_binary_request_header header; struct { uint64_t delta; uint64_t initial; uint32_t expiration; } body; } message; uint8_t bytes[sizeof(protocol_binary_request_header) + 20]; } protocol_binary_request_incr; typedef protocol_binary_request_incr protocol_binary_request_decr; /** * Definition of the response from an incr or decr command * command. * See section 4 */ typedef union { struct { protocol_binary_response_header header; struct { uint64_t value; } body; } message; uint8_t bytes[sizeof(protocol_binary_response_header) + 8]; } protocol_binary_response_incr; typedef protocol_binary_response_incr protocol_binary_response_decr; /** * Definition of the quit * See section 4 */ typedef protocol_binary_request_no_extras protocol_binary_request_quit; /** * Definition of the packet returned by the quit command * See section 4 */ typedef protocol_binary_response_no_extras protocol_binary_response_quit; /** * Definition of the packet used by append and prepend command * See section 4 */ typedef protocol_binary_request_no_extras protocol_binary_request_append; typedef protocol_binary_request_no_extras protocol_binary_request_prepend; /** * Definition of the packet returned from a successful append or prepend * See section 4 */ typedef protocol_binary_response_no_extras protocol_binary_response_append; typedef protocol_binary_response_no_extras protocol_binary_response_prepend; /** * Definition of the packet used by the version command * See section 4 */ typedef protocol_binary_request_no_extras protocol_binary_request_version; /** * Definition of the packet returned from a successful version command * See section 4 */ typedef protocol_binary_response_no_extras protocol_binary_response_version; /** * Definition of the packet used by the stats command. * See section 4 */ typedef protocol_binary_request_no_extras protocol_binary_request_stats; /** * Definition of the packet returned from a successful stats command * See section 4 */ typedef protocol_binary_response_no_extras protocol_binary_response_stats; /** * Definition of the packet used by the touch command. */ typedef union { struct { protocol_binary_request_header header; struct { uint32_t expiration; } body; } message; uint8_t bytes[sizeof(protocol_binary_request_header) + 4]; } protocol_binary_request_touch; /** * Definition of the packet returned from the touch command */ typedef protocol_binary_response_no_extras protocol_binary_response_touch; /** * Definition of the packet used by the GAT(Q) command. */ typedef union { struct { protocol_binary_request_header header; struct { uint32_t expiration; } body; } message; uint8_t bytes[sizeof(protocol_binary_request_header) + 4]; } protocol_binary_request_gat; typedef protocol_binary_request_gat protocol_binary_request_gatq; typedef protocol_binary_request_gat protocol_binary_request_gatk; typedef protocol_binary_request_gat protocol_binary_request_gatkq; /** * Definition of the packet returned from the GAT(Q) */ typedef protocol_binary_response_get protocol_binary_response_gat; typedef protocol_binary_response_get protocol_binary_response_gatq; typedef protocol_binary_response_get protocol_binary_response_gatk; typedef protocol_binary_response_get protocol_binary_response_gatkq; /** * Definition of a request for a range operation. * See http://code.google.com/p/memcached/wiki/RangeOps * * These types are used for range operations and exist within * this header for use in other projects. Range operations are * not expected to be implemented in the memcached server itself. */ typedef union { struct { protocol_binary_response_header header; struct { uint16_t size; uint8_t reserved; uint8_t flags; uint32_t max_results; } body; } message; uint8_t bytes[sizeof(protocol_binary_request_header) + 4]; } protocol_binary_request_rangeop; typedef protocol_binary_request_rangeop protocol_binary_request_rget; typedef protocol_binary_request_rangeop protocol_binary_request_rset; typedef protocol_binary_request_rangeop protocol_binary_request_rsetq; typedef protocol_binary_request_rangeop protocol_binary_request_rappend; typedef protocol_binary_request_rangeop protocol_binary_request_rappendq; typedef protocol_binary_request_rangeop protocol_binary_request_rprepend; typedef protocol_binary_request_rangeop protocol_binary_request_rprependq; typedef protocol_binary_request_rangeop protocol_binary_request_rdelete; typedef protocol_binary_request_rangeop protocol_binary_request_rdeleteq; typedef protocol_binary_request_rangeop protocol_binary_request_rincr; typedef protocol_binary_request_rangeop protocol_binary_request_rincrq; typedef protocol_binary_request_rangeop protocol_binary_request_rdecr; typedef protocol_binary_request_rangeop protocol_binary_request_rdecrq; #ifdef __cplusplus } #endif #endif /* PROTOCOL_BINARY_H */ memcached-1.6.20/t/0000755000175000017500000000000014427543277010771 500000000000000memcached-1.6.20/t/chunked-extstore.t0000664000175000017500000001343214340006077014361 00000000000000#!/usr/bin/env perl # Networked logging tests. use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $ext_path; if (!supports_extstore()) { plan skip_all => 'extstore not enabled'; exit 0; } $ext_path = "/tmp/extstore.$$"; my $server = new_memcached("-m 64 -U 0 -o ext_page_size=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=0,ext_max_frag=0,ext_path=$ext_path:64m,slab_chunk_max=16384,slab_automove=0,ext_max_sleep=100000"); my $sock = $server->sock; # Only able to disable compaction at runtime. # FIXME: -1 for disabled? :( print $sock "extstore compact_under 0\r\n"; my $res = <$sock>; # Wait until all items have flushed sub wait_for_ext { my $sum = 1; while ($sum != 0) { my $s = mem_stats($sock, "items"); $sum = 0; for my $key (keys %$s) { if ($key =~ m/items:(\d+):number/) { # Ignore classes which can contain extstore items next if $1 < 3; $sum += $s->{$key}; } } sleep 1 if $sum != 0; } } # We're testing to ensure item chaining doesn't corrupt or poorly overlap # data, so create a non-repeating pattern. my @parts = (); for (1 .. 8000) { push(@parts, $_); } my $pattern = join(':', @parts); my $plen = length($pattern); print $sock "set pattern 0 0 $plen\r\n$pattern\r\n"; is(scalar <$sock>, "STORED\r\n", "stored pattern successfully"); # Stash two more for later test print $sock "set pattern2 0 0 $plen noreply\r\n$pattern\r\n"; print $sock "set pattern3 0 0 $plen noreply\r\n$pattern\r\n"; wait_for_ext(); mem_get_is($sock, "pattern", $pattern); for (1..5) { my $size = 400 * 1024; my $data = "x" x $size; print $sock "set foo$_ 0 0 $size\r\n$data\r\n"; my $res = <$sock>; is($res, "STORED\r\n", "stored some big items"); } wait_for_ext(); { my $max = 1024 * 1024; my $big = "a big value that's > .5M and < 1M. "; while (length($big) * 2 < $max) { $big = $big . $big; } my $biglen = length($big); for (1..40) { print $sock "set toast$_ 0 0 $biglen\r\n$big\r\n"; is(scalar <$sock>, "STORED\r\n", "stored big"); } wait_for_ext(); for (1..40) { mem_get_is($sock, "toast$_", $big); } my $stats = mem_stats($sock); cmp_ok($stats->{extstore_page_allocs}, '>', 0, 'at least one page allocated'); cmp_ok($stats->{extstore_objects_written}, '>', 25, 'some objects written'); cmp_ok($stats->{extstore_bytes_written}, '>', $max * 2, 'some bytes written'); cmp_ok($stats->{get_extstore}, '>', 5, 'multiple objects fetched'); cmp_ok($stats->{extstore_objects_read}, '>', 0, 'one object read'); cmp_ok($stats->{extstore_bytes_read}, '>', $max * 2, 'some bytes read'); is($stats->{badcrc_from_extstore}, 0, 'CRC checks successful'); } # fill to eviction { my $keycount = 1250; for (1 .. $keycount) { print $sock "set mfoo$_ 0 0 $plen noreply\r\n$pattern\r\n"; wait_for_ext() if $_ % 500 == 0; } # because item_age is set to 2s. wait_for_ext(); my $stats = mem_stats($sock); is($stats->{evictions}, 0, 'memory evictions should still be zero'); cmp_ok($stats->{extstore_page_evictions}, '>', 0, 'at least one page evicted'); cmp_ok($stats->{extstore_objects_evicted}, '>', 0, 'at least one object evicted'); cmp_ok($stats->{extstore_bytes_evicted}, '>', 0, 'some bytes evicted'); cmp_ok($stats->{extstore_pages_free}, '<', 2, 'most pages are used'); is($stats->{miss_from_extstore}, 0, 'no misses'); # original "pattern" key should be gone. cmp_ok($stats->{recache_from_extstore}, '<', 1, 'no recaching happening'); cmp_ok($stats->{extstore_compact_rescues}, '<', 1, 'no compaction rescues happened'); mem_get_is($sock, "pattern", undef, "original pattern key is gone"); $stats = mem_stats($sock); is($stats->{miss_from_extstore}, 1, 'one extstore miss'); print $sock "get pattern2 pattern3\r\n"; is(scalar <$sock>, "END\r\n", "multiget double miss"); $stats = mem_stats($sock); is($stats->{miss_from_extstore}, 3, 'three extstore misses'); } # Let compaction run. { for (1..40) { print $sock "delete toast$_ noreply\r\n" if $_ % 2 == 0; } for (1..1250) { # Force a read so objects don't get skipped. print $sock "add mfoo$_ 0 0 1 noreply\r\n1\r\n" if $_ % 2 == 1; } for (1..1250) { # Delete lots of objects to trigger compaction. print $sock "delete mfoo$_ noreply\r\n" if $_ % 2 == 0; } print $sock "extstore compact_under 4\r\n"; my $res = <$sock>; is($res, "OK\r\n", 'set compact_under'); print $sock "extstore drop_under 3\r\n"; $res = <$sock>; is($res, "OK\r\n", 'set drop_under'); print $sock "extstore max_frag 0.9\r\n"; $res = <$sock>; is($res, "OK\r\n", 'set max_frag'); # Give compaction some time to run. for (1 .. 30) { my $stats = mem_stats($sock); last if $stats->{extstore_pages_free} > 2; sleep 1; } my $stats = mem_stats($sock); cmp_ok($stats->{extstore_pages_free}, '>', 2, 'some pages now free'); cmp_ok($stats->{extstore_compact_rescues}, '>', 0, 'some compaction rescues happened'); # Some of the early items got evicted for (750..1250) { # everything should validate properly. mem_get_is($sock, "mfoo$_", $pattern) if $_ % 2 == 1; } } # test recache { print $sock "extstore recache_rate 1\r\n"; is(scalar <$sock>, "OK\r\n", "upped recache rate"); for (1150..1250) { mem_get_is($sock, "mfoo$_", $pattern) if $_ % 2 == 1; } my $stats = mem_stats($sock); cmp_ok($stats->{recache_from_extstore}, '>', 25, 'recaching happening'); } done_testing(); END { unlink $ext_path if $ext_path; } memcached-1.6.20/t/malicious-commands.t0000664000175000017500000000147014340006077014650 00000000000000#!/usr/bin/env perl # These command strings are always expected to be malicious and as such we # should just hang up on them. use strict; use Test::More tests => 3; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my @strs = ( "GET / HTTP/1.0", "PUT /asdf/asd/fasdfasdf/sadf HTTP/1.1", "DELETE HTTP/1.1" ); for my $str (@strs) { my $server = new_memcached(); my $sock = $server->sock; print $sock "$str\r\n"; # Five seconds ought to be enough to get hung up on. my $oldalarmt = alarm(5); # Verify we can't read anything. my $bytesread = -1; eval { local $SIG{'ALRM'} = sub { die "timeout" }; my $data = ""; $bytesread = sysread($sock, $data, 24), }; is($bytesread, 0, $str); # Restore signal stuff. alarm($oldalarmt); } memcached-1.6.20/t/refhang.t0000664000175000017500000000347214340006077012502 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; plan skip_all => 'Test is flaky. Needs special hooks.'; plan tests => 127; # start up a server with 10 maximum connections my $server = new_memcached("-m 6"); my $sock = $server->sock; my $hangsock = $server->new_sock; my $hangsock2 = $server->new_sock; my $value = "B"x66560; my $key = 0; # These aren't set to expire. my $mget = ''; for ($key = 0; $key < 120; $key++) { $mget .= "key$key " if $key < 115; print $sock "set key$key 0 0 66560\r\n$value\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key$key"); } chop $mget; my $stats = mem_stats($sock, "items"); isnt($stats->{"items:31:evicted"}, "0", "check evicted"); my $lrutail_reflocked = $stats->{"items:31:lrutail_reflocked"}; is($lrutail_reflocked, "0", "check no slab lrutail_reflocked"); $stats = mem_stats($sock); is($stats->{"lrutail_reflocked"}, "0", "check no total lrutail_reflocked"); # Don't intend to read the results, need to fill the socket. # TODO: This test would be smarter if we cranked down the socket buffers # first? Or perhaps used a unix domain socket. print $hangsock "get $mget\r\n"; #sleep 8; # Now we try a bunch of sets again, and see if they start coming back as OOM's for ($key = 121; $key < 240; $key++) { print $sock "set key$key 0 0 66560\r\n$value\r\n"; my $res = scalar <$sock>; } $stats = mem_stats($sock, "items"); # Some items will OOM since we only clear a handful per alloc attempt. ok($stats->{"items:31:outofmemory"} > 0, "some ooms happened"); ok($stats->{"items:31:outofmemory"} < 20, "fewer than 20 ooms"); isnt($stats->{"items:31:lrutail_reflocked"}, "0", "nonzero lrutail_reflocked"); $stats = mem_stats($sock); isnt($stats->{"lrutail_reflocked"}, "0", "nonzero total lrutail_reflocked"); memcached-1.6.20/t/sasl/0000775000175000017500000000000013704126374011725 500000000000000memcached-1.6.20/t/sasl/memcached.conf0000664000175000017500000000011713704126374014421 00000000000000mech_list: plain cram-md5 log_level: 5 sasldb_path: /tmp/test-memcached.sasldb memcached-1.6.20/t/metaget.t0000664000175000017500000006201214427543277012527 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; # command syntax: # mg [key] [flags]\r\n # response: # VA [size] [flags]\r\n # data\r\n # or: # HD [flags]\r\n # or: # EN\r\n # flags are single 'f' or 'f1234' or 'fTEXT' # # flags: # - s: return item size # - v: return item value # - c: return item cas # - t: return item TTL remaining (-1 for unlimited) # - f: return client flags # - l: return last access time # - h: return whether item has been hit before # - O(token): opaque to copy back. # - k: return key # - q: noreply semantics. # - u: don't bump the item in LRU # updaters: # - N(token): vivify on miss, takes TTL as a argument # - R(token): if token is less than item TTL win for recache # - T(token): update remaining TTL # FIXME: do I need a "if stale and no token sent, flip" explicit flag? # extra response flags: # - W: client has "won" the token # - X: object is stale # - Z: object has sent a winning token # # ms [key] [valuelen] [flags]\r\n # value\r\n # response: # HD [flags]\r\n # HD STORED, NS NOT_STORED, EX EXISTS, NF NOT_FOUND # # flags: # - q: noreply # - F(token): set client flags # - C(token): compare CAS value # - T(token): TTL # - O(token): opaque to copy back. # - k: return key # - I: invalid. set-to-invalid if CAS is older than it should be. # - M(token): mode switch. # - default to "set" # - E: add mode # - A: append mode # - P: prepend mode # - R: replace mode # - S: set mode - not necessary, but could be useful for clients. # # md [key] [flags]\r\n # response: # HD [flags] # flags: # - q: noreply # - T(token): updates TTL # - C(token): compare CAS value # - I: invalidate. mark as stale, bumps CAS. # - O(token): opaque to copy back. # - k: return key # # ma [key] [flags]\r\n # response: # HD [flags]\r\n # HD, NS NOT_STORED, EX EXISTS, NF NOT_FOUND # or: # VA [size] [flags]\r\n # data\r\n # # flags: # q: noreply # N(token): autovivify with supplied TTL # J(token): initial value to use if autovivified # D(token): delta to apply. default 1 # T(token): update TTL # C(token): CAS must match # M(token): mode switch. # - default to "incr" # - I: incr # - +: incr # - D: decr # - -: decr # t: return TTL # c: return current CAS # v: return new value # # mn\r\n # response: # MN\r\n # metaget tests # basic test # - raw mget # - raw mget miss # - raw mget bad key # Test basic parser. { print $sock " \n"; is(scalar <$sock>, "ERROR\r\n", "error from blank command"); } { print $sock "set foo 0 0 2\r\nhi\r\n"; is(scalar <$sock>, "STORED\r\n", "stored test value"); print $sock "me none\r\n"; is(scalar <$sock>, "EN\r\n", "raw mget miss"); print $sock "me foo\r\n"; like(scalar <$sock>, qr/^ME foo /, "raw mget result"); } # mdelete had excess space before newline. { print $sock "md deltest\r\n"; is(scalar <$sock>, "NF\r\n", "delete status is correct"); print $sock "md foo\r\n"; is(scalar <$sock>, "HD\r\n", "delete status is correct"); } # mget with arguments # - set some specific TTL and get it back (within reason) # - get cas # - autovivify and bit-win { print $sock "set foo2 0 90 2\r\nho\r\n"; is(scalar <$sock>, "STORED\r\n", "stored test value"); mget_is({ sock => $sock, flags => 's v', eflags => 's2' }, 'foo2', 'ho', "retrieved test value"); # FIXME: figure out what I meant to do here. #my $res = mget($sock, 'foo2', 's t v'); } { diag "basic mset CAS"; my $key = "msetcas"; print $sock "ms $key 2\r\nbo\r\n"; like(scalar <$sock>, qr/^HD/, "set test key"); my $res = mget($sock, $key, 'c'); ok(get_flag($res, 'c'), "got a cas value back"); my $cas = get_flag($res, 'c'); my $badcas = $cas + 10; print $sock "ms $key 2 c C$badcas\r\nio\r\n"; like(scalar <$sock>, qr/^EX c0/, "zeroed out cas on return"); print $sock "ms $key 2 c C$cas\r\nio\r\n"; like(scalar <$sock>, qr/^HD c\d+/, "success on correct cas"); } { diag "mdelete with cas"; my $key = "mdeltest"; print $sock "ms $key 2\r\nzo\r\n"; like(scalar <$sock>, qr/^HD/, "set test key"); my $res = mget($sock, $key, 'c'); ok(get_flag($res, 'c'), "got a cas value back"); my $cas = get_flag($res, 'c'); my $badcas = $cas + 10; print $sock "md $key C$badcas\r\n"; like(scalar <$sock>, qr/^EX/, "mdelete fails for wrong CAS"); print $sock "md $key C$cas\r\n"; like(scalar <$sock>, qr/^HD/, "mdeleted key"); } { diag "encoded binary keys"; # 44OG44K544OI is "tesuto" in katakana my $tesuto = "44OG44K544OI"; print $sock "ms $tesuto 2 b\r\npo\r\n"; like(scalar <$sock>, qr/^HD/, "set with encoded key"); my $res = mget($sock, $tesuto, 'v'); ok(! exists $res->{val}, "encoded key doesn't exist"); $res = mget($sock, $tesuto, 'b v k'); ok(exists $res->{val}, "decoded key exists"); ok(get_flag($res, 'k') eq $tesuto, "key returned encoded"); # TODO: test k is returned properly from ms. # validate the store data is smaller somehow? } { diag "marithmetic tests"; print $sock "ma mo\r\n"; like(scalar <$sock>, qr/^NF\r/, "incr miss"); print $sock "ma mo D1\r\n"; like(scalar <$sock>, qr/^NF\r/, "incr miss with argument"); print $sock "set mo 0 0 1\r\n1\r\n"; like(scalar <$sock>, qr/^STORED/, "stored with set"); print $sock "ma mo\r\n"; like(scalar <$sock>, qr/^HD\r/, "incr'd a set value"); print $sock "set mo 0 0 1\r\nq\r\n"; like(scalar <$sock>, qr/^STORED/, "stored with set"); print $sock "ma mo\r\n"; like(scalar <$sock>, qr/^CLIENT_ERROR /, "cannot incr non-numeric value"); print $sock "ma mu N90\r\n"; like(scalar <$sock>, qr/^HD\r/, "incr with seed"); my $res = mget($sock, 'mu', 's t v Ofoo k'); ok(keys %$res, "not a miss"); ok(find_flags($res, 'st'), "got main flags back"); is($res->{val}, '0', "seeded default value"); my $ttl = get_flag($res, 't'); ok($ttl > 10 && $ttl < 91, "TTL is within requested window: $ttl"); $res = marith($sock, 'mu', 'T300 v t'); ok(keys %$res, "not a miss"); is($res->{val}, '1', "incremented once"); $ttl = get_flag($res, 't'); ok($ttl > 150 && $ttl < 301, "TTL is within requested window: $ttl"); $res = marith($sock, 'mi', 'N0 J13 v t'); ok(keys %$res, "not a miss"); is($res->{val}, '13', 'seeded on a missed value'); $res = marith($sock, 'mi', 'N0 J13 v t'); is($res->{val}, '14', 'incremented from seed'); $res = marith($sock, 'mi', 'N0 J13 v t D30'); is($res->{val}, '44', 'specific increment'); $res = marith($sock, 'mi', 'N0 J13 v t MD D22'); is($res->{val}, '22', 'specific decrement'); $res = marith($sock, 'mi', 'N0 J13 v t MD D9000'); is($res->{val}, '0', 'land at 0 for over-decrement'); print $sock "ma mi q D1\r\nmn\r\n"; like(scalar <$sock>, qr/^MN\r/, "quiet increment"); # CAS routines. $res = marith($sock, 'mc', 'N0 c v'); my $cas = get_flag($res, 'c'); # invalid CAS. print $sock "ma mc N0 C99999 v\r\n"; like(scalar <$sock>, qr/^EX/, 'CAS mismatch'); # valid CAS $res = marith($sock, 'mc', "N0 C$cas c v"); my $ncas = get_flag($res, 'c'); is($res->{val}, '1', 'ticked after CAS increment'); isnt($cas, $ncas, 'CAS increments during modification'); } # mset tests with mode switch flag (M) { diag "mset mode switch"; print $sock "ms modedefault 2 T120\r\naa\r\n"; like(scalar <$sock>, qr/^HD/, "default set mode"); mget_is({ sock => $sock, flags => 's v', eflags => 's2' }, 'modedefault', 'aa', "retrieved test value"); # Fail an add print $sock "ms modedefault 2 T120 ME\r\naa\r\n"; like(scalar <$sock>, qr/^NS/, "add mode gets NOT_STORED"); # Win an add print $sock "ms modetest 2 T120 ME\r\nbb\r\n"; like(scalar <$sock>, qr/^HD/, "add mode"); mget_is({ sock => $sock, flags => 's v', eflags => 's2' }, 'modetest', 'bb', "retrieved test value"); # append print $sock "ms modetest 2 T120 MA\r\ncc\r\n"; like(scalar <$sock>, qr/^HD/, "append mode"); mget_is({ sock => $sock, flags => 's v', eflags => 's4' }, 'modetest', 'bbcc', "retrieved test value"); # prepend print $sock "ms modetest 2 T120 MP\r\naa\r\n"; like(scalar <$sock>, qr/^HD/, "append mode"); mget_is({ sock => $sock, flags => 's v', eflags => 's6' }, 'modetest', 'aabbcc', "retrieved test value"); # replace print $sock "ms modereplace 2 T120 MR\r\nzz\r\n"; like(scalar <$sock>, qr/^NS/, "fail replace mode"); print $sock "ms modetest 2 T120 MR\r\nxx\r\n"; like(scalar <$sock>, qr/^HD/, "replace mode"); mget_is({ sock => $sock, flags => 's v', eflags => 's2' }, 'modetest', 'xx', "retrieved test value"); # explicit set print $sock "ms modetest 2 T120 MS\r\nyy\r\n"; like(scalar <$sock>, qr/^HD/, "force set mode"); # invalid mode print $sock "ms modetest 2 T120 MZ\r\ntt\r\n"; like(scalar <$sock>, qr/^CLIENT_ERROR /, "invalid mode"); } # Append tests { print $sock "ms appendcas 2 MA C5000 T30\r\nhi\r\n"; is(scalar <$sock>, "NS\r\n", "ms append with bad cas"); print $sock "ms appendcas 2 MA T30\r\nhi\r\n"; is(scalar <$sock>, "NS\r\n", "ms append straight miss"); print $sock "ms appendcas 2 T30 c\r\nho\r\n"; my $res = <$sock>; my $r = parse_res($res); my $cas = get_flag($r, 'c'); print $sock "ms appendcas 2 MA C$cas T30\r\nhi\r\n"; is(scalar <$sock>, "HD\r\n", "ms append with good cas"); # Autovivify append. print $sock "ms appendviv 2 MA N30\r\nmo\r\n"; is(scalar <$sock>, "HD\r\n", "ms append with autovivify"); mget_is({ sock => $sock, flags => 's v', eflags => 's2' }, 'appendviv', 'mo', "retrieved autoviv append"); # Test full size on append. print $sock "ms appendviv 2 MA N30 s\r\nko\r\n"; is(scalar <$sock>, "HD s4\r\n", "got appended length"); } # lease-test, use two sockets? one socket should be fine, actually. # - get a win on autovivify # - get a loss on the same command # - have a set/cas fail # - have a cas succeed # - repeat for "triggered on TTL" # - test just modifying the TTL (touch) # - test fetching without value { my $res = mget($sock, 'needwin', 's c v N30 t'); like($res->{flags}, qr/[scvNt]+/, "got main flags back"); like($res->{flags}, qr/W/, "got a win result"); unlike($res->{flags}, qr/Z/, "no token already sent warning"); # asked for size and TTL. size should be 0, TTL should be > 0 and < 30 is($res->{size}, 0, "got zero size: autovivified response"); my $ttl = get_flag($res, 't'); ok($ttl > 0 && $ttl <= 30, "auto TTL is within requested window: $ttl"); # try to fail this time. { my $res = mget($sock, 'needwin', 's t c v N30'); ok(keys %$res, "got a non-empty response"); unlike($res->{flags}, qr/W/, "not a win result"); like($res->{flags}, qr/Z/, "object already sent win result"); } # set back with the wrong CAS print $sock "ms needwin 2 C5000 T120\r\nnu\r\n"; like(scalar <$sock>, qr/^EX/, "failed to SET: CAS didn't match"); # again, but succeed. # TODO: the actual CAS command should work here too? my $cas = get_flag($res, 'c'); print $sock "ms needwin 2 C$cas T120\r\nmu\r\n"; like(scalar <$sock>, qr/^HD/, "SET: CAS matched"); # now we repeat the original mget, but the data should be different. $res = mget($sock, 'needwin', 's k t c v N30'); ok(keys %$res, "not a miss"); ok(find_flags($res, 'sktc'), "got main flags back"); unlike($res->{flags}, qr/[WZ]/, "not a win or token result"); is(get_flag($res, 'k'), 'needwin', "key matches"); $ttl = get_flag($res, 't'); ok($ttl > 100 && $ttl <= 120, "TTL is within requested window: $ttl"); is($res->{val}, "mu", "value matches"); # now we do the whole routine again, but for "triggered on TTL being low" # TTL was set to 120 just now, so anything lower than this should trigger. $res = mget($sock, 'needwin', 's t c v N30 R130'); ok(find_flags($res, 'stc'), "got main flags back"); like($res->{flags}, qr/W/, "got a win result"); unlike($res->{flags}, qr/Z/, "no token already sent warning"); is($res->{val}, "mu", "value matches"); # try to fail this time. { my $res = mget($sock, 'needwin', 's t c v N30 R130'); ok(keys %$res, "got a non-empty response"); unlike($res->{flags}, qr/W/, "not a win result"); like($res->{flags}, qr/Z/, "object already sent win result"); is($res->{val}, "mu", "value matches"); } # again, but succeed. $cas = get_flag($res, 'c'); print $sock "ms needwin 4 C$cas T300\r\nzuuu\r\n"; like(scalar <$sock>, qr/^HD/, "SET: CAS matched"); # now we repeat the original mget, but the data should be different. $res = mget($sock, 'needwin', 's t c v N30'); ok(keys %$res, "not a miss"); ok(find_flags($res, 'stc'), "got main flags back"); unlike($res->{flags}, qr/[WZ]/, "not a win or token result"); $ttl = get_flag($res, 't'); ok($ttl > 250 && $ttl <= 300, "TTL is within requested window"); ok($res->{size} == 4, "Size returned correctly"); is($res->{val}, "zuuu", "value matches: " . $res->{val}); } # test get-and-touch mode { # Set key with lower initial TTL. print $sock "ms gatkey 4 T100\r\nooom\r\n"; like(scalar <$sock>, qr/^HD/, "set gatkey"); # Coolish side feature and/or bringer of bugs: 't' before 'T' gives TTL # before adjustment. 'T' before 't' gives TTL after adjustment. # Here we want 'T' before 't' to ensure we did adjust the value. my $res = mget($sock, 'gatkey', 's v T300 t'); ok(keys %$res, "not a miss"); unlike($res->{flags}, qr/[WZ]/, "not a win or token result"); my $ttl = get_flag($res, 't'); ok($ttl > 280 && $ttl <= 300, "TTL is within requested window: $ttl"); } # test no-value mode { # Set key with lower initial TTL. print $sock "ms hidevalue 4 T100\r\nhide\r\n"; like(scalar <$sock>, qr/^HD/, "set hidevalue"); my $res = mget($sock, 'hidevalue', 's t'); ok(keys %$res, "not a miss"); is($res->{val}, undef, "no value returned"); $res = mget($sock, 'hidevalue', 's t v'); ok(keys %$res, "not a miss"); is($res->{val}, 'hide', "real value returned"); } # test hit-before? flag { print $sock "ms hitflag 3 T100\r\nhit\r\n"; like(scalar <$sock>, qr/^HD/, "set hitflag"); my $res = mget($sock, 'hitflag', 's t h'); ok(keys %$res, "not a miss"); is(get_flag($res, 'h'), 0, "not been hit before"); $res = mget($sock, 'hitflag', 's t h'); ok(keys %$res, "not a miss"); is(get_flag($res, 'h'), 1, "been hit before"); } # test no-update flag { print $sock "ms noupdate 3 T100\r\nhit\r\n"; like(scalar <$sock>, qr/^HD/, "set noupdate"); my $res = mget($sock, 'noupdate', 's t u h'); ok(keys %$res, "not a miss"); is(get_flag($res, 'h'), 0, "not been hit before"); # _next_ request should show a hit. # gets modified here but returns previous state. $res = mget($sock, 'noupdate', 's t h'); is(get_flag($res, 'h'), 0, "still not a hit"); $res = mget($sock, 'noupdate', 's t u h'); is(get_flag($res, 'h'), 1, "finally a hit"); } # test last-access time { print $sock "ms la_test 2 T100\r\nla\r\n"; like(scalar <$sock>, qr/^HD/, "set la_test"); sleep 2; my $res = mget($sock, 'la_test', 's t l'); ok(keys %$res, "not a miss"); isnt(get_flag($res, 'l'), 0, "been over a second since most recently accessed"); } # high level tests: # - mget + mset with serve-stale # - set a value # - mget it back. should be no XZW tokens # - invalidate via mdelete and mget/revalidate with mset # - remember failure scenarios! # - TTL timed out? # - CAS too high? # - also test re-setting as stale (CAS is below requested) # - this should probably be conditional. { diag "starting serve stale with mdelete"; my ($ttl, $cas, $res); print $sock "set toinv 0 0 3\r\nmoo\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key 'toinv'"); $res = mget($sock, 'toinv', 's v'); unlike($res->{flags}, qr/[XWZ]/, "no extra flags"); # Lets mark the sucker as invalid, and drop its TTL to 30s diag "running mdelete"; print $sock "md toinv I T30\r\n"; like(scalar <$sock>, qr/^HD/, "mdelete'd key"); # TODO: decide on if we need an explicit flag for "if I fetched a stale # value, does winning matter? # I think it's probably fine. clients can always ignore the win, or we can # add an option later to "don't try to revalidate if stale", perhaps. $res = mget($sock, 'toinv', 's t c v'); ok(keys %$res, "not a miss"); ok(find_flags($res, 'stc'), "got main flags back"); like($res->{flags}, qr/W/, "won the recache"); like($res->{flags}, qr/X/, "item is marked stale"); $ttl = get_flag($res, 't'); ok($ttl > 0 && $ttl <= 30, "TTL is within requested window"); ok($res->{size} == 3, "Size returned correctly"); is($res->{val}, "moo", "value matches"); diag "trying to fail then stale set via mset"; print $sock "ms toinv 1 T90 C0\r\nf\r\n"; like(scalar <$sock>, qr/^EX/, "failed to SET: low CAS didn't match"); print $sock "ms toinv 1 I T90 C1\r\nf\r\n"; like(scalar <$sock>, qr/^HD/, "SET an invalid/stale item"); diag "confirm item still stale, and TTL wasn't raised."; $res = mget($sock, 'toinv', 's t c v'); like($res->{flags}, qr/X/, "item is marked stale"); like($res->{flags}, qr/Z/, "win token already sent"); unlike($res->{flags}, qr/W/, "didn't win: token already sent"); $ttl = get_flag($res, 't'); ok($ttl > 0 && $ttl <= 30, "TTL wasn't modified"); # TODO: CAS too high? diag "do valid mset"; $cas = get_flag($res, 'c'); print $sock "ms toinv 1 T90 C$cas\r\ng\r\n"; like(scalar <$sock>, qr/^HD/, "SET over the stale item"); $res = mget($sock, 'toinv', 's t c v'); ok(keys %$res, "not a miss"); unlike($res->{flags}, qr/[WXZ]/, "no stale, win, or tokens"); $ttl = get_flag($res, 't'); ok($ttl > 30 && $ttl <= 90, "TTL was modified"); ok($cas != get_flag($res, 'c'), "CAS was updated"); is($res->{size}, 1, "size updated"); is($res->{val}, "g", "value was updated"); } # Quiet flag suppresses most output. Badly invalid commands will still # generate something. Not weird to parse like 'noreply' token was... # mget's with hits should return real data. { diag "testing quiet flag"; print $sock "ms quiet 2 q\r\nmo\r\n"; print $sock "md quiet q\r\n"; print $sock "mg quiet s v q\r\n"; diag "now purposefully cause an error\r\n"; print $sock "ms quiet\r\n"; like(scalar <$sock>, qr/^CLIENT_ERROR/, "resp not HD, or EN"); # Now try a pipelined get. Throw an mnop at the end print $sock "ms quiet 2 q\r\nbo\r\n"; print $sock "mg quiet v q\r\nmg quiet v q\r\nmg quietmiss v q\r\nmn\r\n"; # Should get back VA/data/VA/data/EN like(scalar <$sock>, qr/^VA 2/, "get response"); like(scalar <$sock>, qr/^bo/, "get value"); like(scalar <$sock>, qr/^VA 2/, "get response"); like(scalar <$sock>, qr/^bo/, "get value"); like(scalar <$sock>, qr/^MN/, "end token"); # "quiet" won't do anything with autoviv, since the only case (miss) # should return data anyway. print $sock "mg quietautov s N30 t q\r\n"; like(scalar <$sock>, qr/^HD s0/, "quiet doesn't override autovivication"); } { my $k = 'otest'; diag "testing mget opaque"; print $sock "ms $k 2 T100\r\nra\r\n"; like(scalar <$sock>, qr/^HD/, "set $k"); my $res = mget($sock, $k, 't v Oopaque'); is(get_flag($res, 'O'), 'opaque', "O flag returned opaque"); } { diag "flag and token count errors"; print $sock "mg foo m o o o o o o o o o\r\n"; like(scalar <$sock>, qr/^CLIENT_ERROR invalid flag/, "gone silly with flags"); } { diag "pipeline test"; print $sock "ms foo 2 T100\r\nna\r\n"; like(scalar <$sock>, qr/^HD/, "set foo"); print $sock "mg foo s\r\nmg foo s\r\nquit\r\nmg foo s\r\n"; like(scalar <$sock>, qr/^HD /, "got resp"); like(scalar <$sock>, qr/^HD /, "got resp"); is(scalar <$sock>, undef, "final get didn't run"); } # TODO: move wait_for_ext into Memcached.pm sub wait_for_ext { my $sock = shift; my $target = shift || 0; my $sum = $target + 1; while ($sum > $target) { my $s = mem_stats($sock, "items"); $sum = 0; for my $key (keys %$s) { if ($key =~ m/items:(\d+):number/) { # Ignore classes which can contain extstore items next if $1 < 3; $sum += $s->{$key}; } } sleep 1 if $sum > $target; } } my $ext_path; # Do a basic extstore test if enabled. if (supports_extstore()) { diag "mget + extstore tests"; $ext_path = "/tmp/extstore.$$"; my $server = new_memcached("-m 64 -U 0 -o ext_page_size=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path:64m,slab_automove=0,ext_compact_under=1,no_lru_crawler"); my $sock = $server->sock; my $value; { my @chars = ("C".."Z"); for (1 .. 20000) { $value .= $chars[rand @chars]; } } my $keycount = 10; for (1 .. $keycount) { print $sock "set nfoo$_ 0 0 20000 noreply\r\n$value\r\n"; } wait_for_ext($sock); mget_is({ sock => $sock, flags => 's v', eflags => 's20000' }, 'nfoo1', $value, "retrieved test value"); my $stats = mem_stats($sock); cmp_ok($stats->{get_extstore}, '>', 0, 'one object was fetched'); my $ovalue = $value; for (1 .. 4) { $value .= $ovalue; } # Fill to eviction. $keycount = 1000; for (1 .. $keycount) { print $sock "set mfoo$_ 0 0 100000 noreply\r\n$value\r\n"; # wait to avoid memory evictions wait_for_ext($sock, 1) if ($_ % 250 == 0); } print $sock "mg mfoo1 s v\r\n"; is(scalar <$sock>, "EN\r\n"); print $sock "mg mfoo1 s v q\r\nmn\r\n"; is(scalar <$sock>, "MN\r\n"); $stats = mem_stats($sock); cmp_ok($stats->{miss_from_extstore}, '>', 0, 'at least one miss'); } ### # takes hash: # - sock # - args (metaget flags) # - array of tokens # - array of expected response tokens # returns hash: # - win (if won a condition) # - array of tokens # - value, etc? # useful to chain together for further requests. # works only with single line values. no newlines in value. # FIXME: some workaround for super long values :| # TODO: move this to lib/MemcachedTest.pm sub mget_is { # single line values only my ($o, $key, $val, $msg) = @_; my $dval = defined $val ? "'$val'" : ""; $msg ||= "$key == $dval"; my $s = $o->{sock}; my $flags = $o->{flags}; my $eflags = $o->{eflags} || $flags; print $s "mg $key $flags\r\n"; if (! defined $val) { my $line = scalar <$s>; if ($line =~ /^VA/) { $line .= scalar(<$s>); } Test::More::is($line, "EN\r\n", $msg); } else { my $len = length($val); my $body = scalar(<$s>); my $expected = "VA $len $eflags\r\n$val\r\n"; if (!$body || $body =~ /^EN/) { Test::More::is($body, $expected, $msg); return; } $body .= scalar(<$s>); Test::More::is($body, $expected, $msg); return mget_res($body); } return {}; } # only fetches values without newlines in it. sub mget { my $s = shift; my $key = shift; my $flags = shift; print $s "mg $key $flags\r\n"; my $header = scalar(<$s>); my $val = "\r\n"; if ($header =~ m/^VA/) { $val = scalar(<$s>); } return mget_res($header . $val); } # TODO: share with mget()? sub marith { my $s = shift; my $key = shift; my $flags = shift; print $s "ma $key $flags\r\n"; my $header = scalar(<$s>); my $val = "\r\n"; if ($header =~ m/^VA/) { $val = scalar(<$s>); } return mget_res($header . $val); } # parse out a response sub mget_res { my $resp = shift; my %r = (); if ($resp =~ m/^VA (\d+) ([^\r]+)\r\n(.*)\r\n/gm) { $r{size} = $1; $r{flags} = $2; $r{val} = $3; } elsif ($resp =~ m/^HD\s*([^\r]+)\r\n/gm) { $r{flags} = $1; $r{hd} = 1; } return \%r; } sub parse_res { my $resp = shift; my %r = (); if ($resp =~ m/^(\w\w)\s*([^\r]+)\r\n/gm) { $r{status} = $1; $r{flags} = $2; } return \%r; } sub get_flag { my $res = shift; my $flag = shift; #print STDERR "FLAGS: $res->{flags}\n"; my @flags = split(/ /, $res->{flags}); for my $f (@flags) { if ($f =~ m/^$flag/) { return substr $f, 1; } } } sub find_flags { my $res = shift; my $flags = shift; my @flags = split(//, $flags); for my $f (@flags) { return 0 unless get_flag($res, $f); } return 1; } done_testing(); END { unlink $ext_path if $ext_path; } memcached-1.6.20/t/issue_260.t0000775000175000017500000000450514340006077012610 00000000000000#!/usr/bin/env perl # Issue #260 is a terrible bug. # In order to run this test: # * checkout 1.4.15 # * change TAIL_REPAIR_TIME from (3 * 3600) to 3 # Now it should cause an assert. Patches can be tested to fix it. use strict; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; plan skip_all => "Only possible to test #260 under artificial conditions"; exit 0; plan tests => 11074; # assuming max slab is 1M and default mem is 64M my $server = new_memcached(); my $sock = $server->sock; # create a big value for the largest slab my $max = 1024 * 1024; my $big = 'x' x (1024 * 1024 - 250); ok(length($big) > 512 * 1024); ok(length($big) < 1024 * 1024); # set the big value my $len = length($big); print $sock "set big 0 0 $len\r\n$big\r\n"; is(scalar <$sock>, "STORED\r\n", "stored big"); mem_get_is($sock, "big", $big); # no evictions yet my $stats = mem_stats($sock); is($stats->{"evictions"}, "0", "no evictions to start"); # set many big items, enough to get evictions for (my $i = 0; $i < 100; $i++) { print $sock "set item_$i 0 0 $len\r\n$big\r\n"; is(scalar <$sock>, "STORED\r\n", "stored item_$i"); } # some evictions should have happened my $stats = mem_stats($sock); my $evictions = int($stats->{"evictions"}); ok($evictions == 37, "some evictions happened"); # the first big value should be gone mem_get_is($sock, "big", undef); # the earliest items should be gone too for (my $i = 0; $i < $evictions - 1; $i++) { mem_get_is($sock, "item_$i", undef); } # check that the non-evicted are the right ones for (my $i = $evictions - 1; $i < $evictions + 4; $i++) { mem_get_is($sock, "item_$i", $big); } # Now we fill a slab with incrementable items... for (my $i = 0; $i < 10923; $i++) { print $sock "set sitem_$i 0 0 1\r\n1\r\n"; is(scalar <$sock>, "STORED\r\n", "stored sitem_$i"); } my $stats = mem_stats($sock); my $evictions = int($stats->{"evictions"}); ok($evictions == 38, "one more eviction happened: $evictions"); # That evicted item was the first one we put in. mem_get_is($sock, "sitem_0", undef); sleep 15; # Now we increment the item which should be on the tail. # THIS asserts the memcached-debug binary. print $sock "incr sitem_1 1\r\n"; is(scalar <$sock>, "2\r\n", "incremented to two"); #my $stats = mem_stats($sock, "slabs"); #is($stats->{"1:free_chunks"}, 0, "free chunks should still be 0"); memcached-1.6.20/t/server_key.pem0000664000175000017500000000321314204760331013554 00000000000000-----BEGIN RSA PRIVATE KEY----- MIIEowIBAAKCAQEAyJ//TaBunqtvD1t6Z7ctC+tpa58Zem71spFQcdS0QoS54IyY YYktkMINaNTqHG9t0yhSKQShTSiOODWYG1vzx9pBF4PI1TJAfpC8aYgplpO00UVl rHyITFTcsLEGgn4N06YtUODNawvDdMSWjK+HNNc71zNg4xaZAQZek3eLasM/zp/g RDy8trzoZbNylO7kmWxfqUPkCo0TOEjdCJxRbdbTa9xEsRAPfYeX/KtB5REospvh S41klO4+X7WaA6xk4bg8UXgFuZj4QQs2fx52ompRdS3i+g0A0rmWUOutM8OrjM5J CYJ/aXe3OHCQ5xaca/LAfmGrxDQEqjjcSgBQ7QIDAQABAoIBACmp4HEUgiR9YaEE 1FS5m6dACjKJZdchN/EPcG9TRuQRgDB7wiFvRYEsa3B71up00Y/qbbWK+px1caOG rcHwxJ2aW64wdgKgXvhpwlcAKfLVVdWn3ceGTR/c97/R45Ix71kmx35mUQKL/NlB AirRQPjeQdUdHF/Mj5XA5t8lElTnPSbxTHqTsS4ktwZDz5szMyrMYTIj2Pwe9VJv Q6HpmaWhiMBDtc03yM+v2M4kXrtjYM0z3PGQsH77Of87Cq1E2gtxfroZC7lfsH5G lDffmW6fVGKeRnXya0WKRB58gJh/wF6rdhSbDjtOMl1UuObuFaz7hArI0LLFjiLp hkxt5EECgYEA6tHGsTdW3w3NBSihjqyqJdhHXnRyekJy/LBTyoUtW2yXSP5Dy/Iq ZVkAjxiGnOOuPKfDSCm6eKHKaB4+mhXD1ySclDdiurUg6zfbPjK9nzIuETJAPpR7 Wbl4AzrTdpbFct4svcZa4zx1wbzjlLgKzTonmZTLufMmt7VoypNlxykCgYEA2rii zAnY94uO66WZNaxAHG1DBmz20scpmQGuwqm08Pp0Wecim91gaonJWTV0RLRNXNB8 Y+lTlDCdhGzIaOtSUJBjIVtbaz/X6FuNvuuWRi+No/QtsA35dZeg3vNSlAp/IHKE tqLf7ep9DkheLqNPIv2OMHZNw0BmjeqMjqXvSCUCgYBrayNVllcrGokbPwcI2XvM bC/ZybNEsnkflxn9nwast/RM8+PXvCQg0KIs069gvdbK8IOo0032OSz6jDtfCW3Z UWo/c0a62nkAoUCuJ1APL0lbnH0/I3V6ChoYgCSUL0yLy470EXUqVlIYGmyRb8+h KmVLIIJBwjWH/Hi/ksYQYQKBgQCD1FejXagdhEtvcw+GTz0RJTYJ0HFwl8RVybLY 98rsmDi621p70ZHEhSoMD/D1XCto7uyal87defPnFl4xBu1FS9HEEDloykFLdqtX 0M1xnkXj9U/4VmPuYab/2m8CddUr7HpbTo5j6zrW+f1yZNJVB7jFMvkp304w6Zcw f4la1QKBgCc2ksKWuoSt3Kfv6s2dXRsO4p/osPjQc3bnVK2GiAJAjLf7fqadRdNL jCMzgA+lxRP4dzA0KD6Z8J6ePr6KmGa8b+lbCvQFKvJCWvsLLKqkz/lnfljp8VvA ntXBBQr+46peeLGehVvcprwc4jANagkiQq5DoVDONN+lobRbCM21 -----END RSA PRIVATE KEY----- memcached-1.6.20/t/bogus-commands.t0000775000175000017500000000042314340006077014002 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 1; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; print $sock "boguscommand slkdsldkfjsd\r\n"; is(scalar <$sock>, "ERROR\r\n", "got error back"); memcached-1.6.20/t/issue_61.t0000664000175000017500000000143314340006077012521 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 7; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached("-R 1"); my $sock = $server->sock; print $sock "set foobar 0 0 5\r\nBubba\r\nset foobar 0 0 5\r\nBubba\r\nset foobar 0 0 5\r\nBubba\r\nset foobar 0 0 5\r\nBubba\r\nset foobar 0 0 5\r\nBubba\r\nset foobar 0 0 5\r\nBubba\r\n"; is (scalar <$sock>, "STORED\r\n", "stored foobar"); is (scalar <$sock>, "STORED\r\n", "stored foobar"); is (scalar <$sock>, "STORED\r\n", "stored foobar"); is (scalar <$sock>, "STORED\r\n", "stored foobar"); is (scalar <$sock>, "STORED\r\n", "stored foobar"); is (scalar <$sock>, "STORED\r\n", "stored foobar"); my $stats = mem_stats($sock); cmp_ok ($stats->{"conn_yields"}, ">=", "5", "Got a decent number of yields"); memcached-1.6.20/t/stats-conns.t0000775000175000017500000000456714340006077013355 00000000000000#!/usr/bin/env perl use strict; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; ## First make sure we report UNIX-domain sockets correctly if (supports_unix_socket()) { plan tests => 12; my $filename = "/tmp/memcachetest$$"; my $server = new_memcached("-s $filename"); my $sock = $server->sock; my $stats_sock = $server->new_sock; ok(-S $filename, "creating unix domain socket $filename"); print $sock "set foo 0 0 6\r\n"; sleep(1); # so we can test secs_since_last_cmd is nonzero print $stats_sock "stats conns\r\n"; my $stats; while (<$stats_sock>) { last if /^(\.|END)/; $stats .= $_; } like($stats, qr/STAT \d+:addr /); $stats =~ m/STAT (\d+):addr unix:(.*[^\r\n])/g; my $listen_fd = $1; my $socket_path = $2; # getsockname(2) doesn't return socket path on GNU/Hurd (and maybe others) SKIP: { skip "socket path checking on GNU kernel", 1 if ($^O eq 'gnu'); is($socket_path, $filename, "unix domain socket path reported correctly"); }; $stats =~ m/STAT (\d+):state conn_listening\r\n/g; is($1, $listen_fd, "listen socket fd reported correctly"); like($stats, qr/STAT \d+:state conn_nread/, "one client is sending data"); like($stats, qr/STAT \d+:state conn_parse_cmd/, "one client is in command processing"); like($stats, qr/STAT \d+:secs_since_last_cmd [1-9]\r/, "nonzero secs_since_last_cmd"); like($stats, qr/STAT \d+:listen_addr unix:\/tmp\/memcachetest\d+\r/, "found listen_addr for the UNIX-domain socket"); $server->stop; unlink($filename); } else { plan tests => 4; } ## Now look at TCP my $server = new_memcached("-l 0.0.0.0"); my $sock = $server->sock; my $stats_sock = $server->new_sock; print $sock "set foo 0 0 6\r\n"; print $stats_sock "stats conns\r\n"; my $stats = ''; while (<$stats_sock>) { last if /^(\.|END)/; $stats .= $_; } like($stats, qr/STAT \d+:state conn_listen/, "there is a listen socket"); $stats =~ m/STAT \d+:addr udp:0.0.0.0:(\d+)/; is($1, $server->udpport, "udp port number is correct"); $stats =~ m/STAT \d+:addr tcp:0.0.0.0:(\d+)/; print STDERR "PORT: ", $server->port, "\n"; is($1, $server->port, "tcp port number is correct"); $stats =~ m/STAT \d+:listen_addr tcp:0.0.0.0:(\d+)/; is($1, $server->port, "listen_addr is correct for the tcp port"); memcached-1.6.20/t/stats.t0000775000175000017500000001402414340006077012224 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 113; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached("-I 1024 -o slab_chunk_max=1024,no_lru_crawler,no_lru_maintainer"); my $sock = $server->sock; ## Output looks like this: ## ## STAT pid 22969 ## STAT uptime 13 ## STAT time 1259170891 ## STAT version 1.4.3 ## STAT libevent 1.4.13-stable. ## see doc/protocol.txt for others # note that auth stats are tested in auth specific tests my $stats = mem_stats($sock); # Test number of keys if (MemcachedTest::enabled_tls_testing()) { # when TLS is enabled, stats contains additional keys: # - ssl_handshake_errors # - time_since_server_cert_refresh is(scalar(keys(%$stats)), 85, "expected count of stats values"); } else { is(scalar(keys(%$stats)), 83, "expected count of stats values"); } # Test initial state foreach my $key (qw(curr_items total_items bytes cmd_get cmd_set get_hits evictions get_misses get_expired bytes_written delete_hits delete_misses incr_hits incr_misses decr_hits get_flushed decr_misses listen_disabled_num lrutail_reflocked time_in_listen_disabled_us store_too_large store_no_memory)) { is($stats->{$key}, 0, "initial $key is zero"); } is($stats->{accepting_conns}, 1, "initial accepting_conns is one"); # Do some operations print $sock "set foo 0 0 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", "fooval"); my $stats = mem_stats($sock); foreach my $key (qw(total_items curr_items cmd_get cmd_set get_hits)) { is($stats->{$key}, 1, "after one set/one get $key is 1"); } my $cache_dump = mem_stats($sock, " cachedump 1 100"); ok(defined $cache_dump->{'foo'}, "got foo from cachedump"); print $sock "delete foo\r\n"; is(scalar <$sock>, "DELETED\r\n", "deleted foo"); my $stats = mem_stats($sock); is($stats->{delete_hits}, 1); is($stats->{delete_misses}, 0); print $sock "delete foo\r\n"; is(scalar <$sock>, "NOT_FOUND\r\n", "shouldn't delete foo again"); my $stats = mem_stats($sock); is($stats->{delete_hits}, 1); is($stats->{delete_misses}, 1); # incr stats sub check_incr_stats { my ($ih, $im, $dh, $dm) = @_; my $stats = mem_stats($sock); is($stats->{incr_hits}, $ih); is($stats->{incr_misses}, $im); is($stats->{decr_hits}, $dh); is($stats->{decr_misses}, $dm); } print $sock "incr i 1\r\n"; is(scalar <$sock>, "NOT_FOUND\r\n", "shouldn't incr a missing thing"); check_incr_stats(0, 1, 0, 0); print $sock "decr d 1\r\n"; is(scalar <$sock>, "NOT_FOUND\r\n", "shouldn't decr a missing thing"); check_incr_stats(0, 1, 0, 1); print $sock "set n 0 0 1\r\n0\r\n"; is(scalar <$sock>, "STORED\r\n", "stored n"); print $sock "incr n 3\r\n"; is(scalar <$sock>, "3\r\n", "incr works"); check_incr_stats(1, 1, 0, 1); print $sock "decr n 1\r\n"; is(scalar <$sock>, "2\r\n", "decr works"); check_incr_stats(1, 1, 1, 1); # cas stats sub check_cas_stats { my ($ch, $cm, $cb) = @_; my $stats = mem_stats($sock); is($stats->{cas_hits}, $ch); is($stats->{cas_misses}, $cm); is($stats->{cas_badval}, $cb); } check_cas_stats(0, 0, 0); print $sock "cas c 0 0 1 99999999\r\nz\r\n"; is(scalar <$sock>, "NOT_FOUND\r\n", "missed cas"); check_cas_stats(0, 1, 0); print $sock "set c 0 0 1\r\nx\r\n"; is(scalar <$sock>, "STORED\r\n", "stored c"); my ($id, $v) = mem_gets($sock, 'c'); is('x', $v, 'got the expected value'); print $sock "cas c 0 0 1 99999999\r\nz\r\n"; is(scalar <$sock>, "EXISTS\r\n", "missed cas"); check_cas_stats(0, 1, 1); my ($newid, $v) = mem_gets($sock, 'c'); is('x', $v, 'got the expected value'); print $sock "cas c 0 0 1 $id\r\nz\r\n"; is(scalar <$sock>, "STORED\r\n", "good cas"); check_cas_stats(1, 1, 1); my ($newid, $v) = mem_gets($sock, 'c'); is('z', $v, 'got the expected value'); my $settings = mem_stats($sock, ' settings'); is(1024, $settings->{'maxconns'}); # we run SSL tests over TCP; hence the domain_socket # is expected to be NULL. if (enabled_tls_testing() || !supports_unix_socket()) { is('NULL', $settings->{'domain_socket'}); } else { isnt('NULL', $settings->{'domain_socket'}); } is('on', $settings->{'evictions'}); is('yes', $settings->{'cas_enabled'}); is('no', $settings->{'auth_enabled_sasl'}); is('no', $settings->{'shutdown_command'}); print $sock "stats reset\r\n"; is(scalar <$sock>, "RESET\r\n", "good stats reset"); my $stats = mem_stats($sock); is(0, $stats->{'cmd_get'}); is(0, $stats->{'cmd_set'}); is(0, $stats->{'get_hits'}); is(0, $stats->{'get_misses'}); is(0, $stats->{'get_expired'}); is(0, $stats->{'get_flushed'}); is(0, $stats->{'delete_misses'}); is(0, $stats->{'delete_hits'}); is(0, $stats->{'incr_misses'}); is(0, $stats->{'incr_hits'}); is(0, $stats->{'decr_misses'}); is(0, $stats->{'decr_hits'}); is(0, $stats->{'cas_misses'}); is(0, $stats->{'cas_hits'}); is(0, $stats->{'cas_badval'}); is(0, $stats->{'evictions'}); is(0, $stats->{'reclaimed'}); is(0, $stats->{'lrutail_reflocked'}); # item expired print $sock "set should_expire 0 2678400 6\r\nfooval\r\n"; #2678400 = 31 days in seconds is(scalar <$sock>, "STORED\r\n", "set item to expire"); print $sock "get should_expire\r\n"; is(scalar <$sock>, "END\r\n", "item not returned"); my $stats = mem_stats($sock); is(1, $stats->{'get_expired'}, "get_expired counter is 1"); print $sock "set should_be_flushed 0 0 6\r\nbooval\r\n"; is(scalar <$sock>, "STORED\r\n", "set item to flush"); print $sock "flush_all\r\n"; is(scalar <$sock>, "OK\r\n", "flushed"); print $sock "get should_be_flushed\r\n"; is(scalar <$sock>, "END\r\n", "flushed item not returned"); my $stats = mem_stats($sock); is($stats->{cmd_flush}, 1, "after one flush cmd_flush is 1"); is($stats->{get_flushed}, 1, "after flush and a get, get_flushed is 1"); # item too large my $large = "B" x 2048; my $largelen = length($large); print $sock "set too_large 0 0 $largelen\r\n$large\r\n"; is(scalar <$sock>, "SERVER_ERROR object too large for cache\r\n", "set rejected due to value too large"); $stats = mem_stats($sock); is($stats->{'store_too_large'}, 1, "recorded store failure due to value too large") memcached-1.6.20/t/ssl_proto_version.t0000664000175000017500000000224014340006077014651 00000000000000#!/usr/bin/env perl use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; if (!enabled_tls_testing()) { plan skip_all => 'SSL testing is not enabled'; exit 0; } my $server; my $is_tls_13_available = 0; eval { # ssl_min_version=3 is not recognized when compiled with OpenSSL < 1.1.1 $server = new_memcached('-o ssl_min_version=3'); $is_tls_13_available = 1; }; SKIP: { skip 'TLS v1.3 not available', 1 if !$is_tls_13_available; # Unsupported protocol version $sock = $server->new_sock(undef, 'TLSv1_2'); is(undef, $sock, "handshake failure on unsupported proto version"); } $server = new_memcached('-o ssl_min_version=2'); # Minimum supported protocol version $sock = $server->new_sock(undef, 'TLSv1_2'); print $sock "version\r\n"; like(scalar <$sock>, qr/VERSION/, "handshake with minimum proto version"); SKIP: { skip 'TLS v1.3 not available', 1 if !$is_tls_13_available; # Above minimum supported protocol version $sock = $server->new_sock(undef, 'TLSv1_3'); print $sock "version\r\n"; like(scalar <$sock>, qr/VERSION/, "handshake above minimum proto version"); } done_testing(); memcached-1.6.20/t/cakey.pem0000664000175000017500000000321714204760331012476 00000000000000-----BEGIN RSA PRIVATE KEY----- MIIEpAIBAAKCAQEAvz238GzKt1UpaxgIxv76hlty5hCZKmD5B952MCWBRi7OyYat l0sMjv38pgsICIT68wGqQaTmV4W0XQQ54+NZ3o5ujJaDQX2kLs8x0sjuNkmt5Wt+ orqdxO99lb7f4hpKyGq0OGeqz4nBHCZeqEt37OLxUgGWQtKGVZI0X/m/m4LudmWw ZpLgAp0w5mY+FLaPavLoXQ95+f3htUzgRdzsFWMXi0piH/D4ua2i+ekajf8owxmR 9AIKpAYYoV1J+XexlzVzXG1OPUEkGvbxnoDIHUoL6IM4i/QEI52UL0b+sVVV0fmJ w08mkN95XhW+OhS52lSBdqiC3/uRRF/g8/5nowIDAQABAoIBAQCEOGi3GpChZojn WUugQeP2Br4O4IT1LuyeiylNqnCRlIU2Ah58zs+VAXevWUspkL9sScdr8VWsR23n LafUrniRDgrSurFvEy3zix8YbAF+mTxYtRRt7/ZqlWZPpRNnYOQ5YsTNhqcrLEPO cZzaYKs+pb1RBHXeJ23nNdluTd8y5YYwhAj3pO5Q+A9KlDsXy2ZoJPB+1G7JWKLs Ptub5Qe9FkaeBVIDiyBqiCyilwmqtRX6cefTHb1/1sTSl8fey/MZZWf+vTFN80oR 09cZ5CxRBm/NX9g4on2T8k9RrjwidTki1ovVMpTr/OcT+j6EnrQFc+VqVcCfEsPk xhN5SVSZAoGBAOeSE1nQTABzlFwNj/8U57OMDChBFpb3fqbpLTaeMPTW5MGt4OJm 1/oNRNNTuSVS+z8DHRbErzG8CYgdFvE8t136XbYKzM8AcBTDqAU+sR6IkvWqLITN EVWDyTh04/UN19pstBkb7icsGSv8Rjm4QIis1cPm9eHVlj6v3Lp0zxuPAoGBANNq e0TDeeWweryGyAKlwhEFdxmr/5byejBBYyxqk44OADXCxI6mk5/3k8WGptoM8qeT dHFZLhvJJ2Rpd/GoiBDqEUxDwtvvCCsajOcK1gRvVlQjezgnE2qdXehqM4A8eAsj drPwciq1MJemYYSdgZZ5DQbfU2DtW+vis11fJritAoGANO1jNNzx8gx4tU14QwIB Lz1sLesqgZjRvs5+wgQIBn3zTP0z8Cs3Y/SSbYauQ4Si3jUU+fY8YK6sswqLCtoo wvcNYiU3yHw+IdDSX1iD3Qm0JSgfAr9oHdaAMEIvM/xVAJxl0XNbzGI84pvHZTvi rBpsxVjNjC9oJq3FUmyORasCgYB8HDF7P6nqrfyPeiwmabqQlX3Cg1dK/NPASlJ2 +6Xdqdhztv/+okldilCkj5SZwyocOBMOi4Tm6OKILuYr5nziORaoh8r3o85Ox4pa A+F5vwaV5DJs13uthe5gByBuspDiMRJ5Nbk/2xhInnL3ECPH+w4rr6TZ7N2ej3ou YTJxDQKBgQCowcfZm4N5s1UynZ9CKXCeZ+lhIUBhz2rYSwDJhGaxRaJgq7ABrsT1 2SIZZUOXJ5tAFjLQ5FM6/RQMu1MGEUoJ/whxEn37Zvy/6dk8T1uxpFvNBbCE+QlX ENz3N5p1hTB16+ETumeLH42U2PZMhKpaEyYZHpVun5p/6TtxX3Sf3A== -----END RSA PRIVATE KEY----- memcached-1.6.20/t/slabs-reassign-chunked.t0000664000175000017500000000766714340006077015436 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More tests => 8; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached('-m 60 -o slab_reassign,slab_automove,lru_crawler,lru_maintainer,slab_chunk_max=4096'); my $sock = $server->sock; sub dump_stats { my $s = shift; my $filter = shift || ''; for my $k (sort keys %$s) { if ($filter) { next unless $k =~ m/$filter/; } print STDERR "STAT: $k = ", $s->{$k}, "\n"; } } my $value; { my @chars = ("C".."Z"); for (1 .. 11000) { $value .= $chars[rand @chars]; } } my $keycount = 5100; my $res; for (1 .. $keycount) { # print STDERR "HI $_\n"; print $sock "set nfoo$_ 0 0 11000 noreply\r\n$value\r\n"; # print $sock "set nfoo$_ 0 0 11000\r\n$value\r\n"; # my $res = scalar <$sock>; # print STDERR "RES: $res\n"; } my $todelete = 0; { my $stats = mem_stats($sock); cmp_ok($stats->{curr_items}, '>', 4000, "stored at least 4000 11k items"); $todelete = $stats->{curr_items} / 2; # for ('evictions', 'reclaimed', 'curr_items', 'cmd_set', 'bytes') { # print STDERR "$_: ", $stats->{$_}, "\n"; # } } { my $s = mem_stats($sock, 'slabs'); my $sid; # Find the highest ID to source from. for my $k (keys %$s) { next unless $k =~ m/^(\d+):/; $sid = $s->{$k} if $s->{$k} > $1; } for (my $x = 0; $x < 3; $x++) { print $sock "slabs reassign 17 0\r\n"; my $res = scalar <$sock>; chomp $res; # print STDERR "SLABS REASSIGN RESULT: $res\n"; sleep 1; } } # Make room in old class so rescues can happen when we switch slab classes. #for (1 .. $todelete) { # print $sock "delete nfoo$_ noreply\r\n"; #} # Give LRU mover some time to reclaim slab chunks. #sleep 1; { my $stats = mem_stats($sock); cmp_ok($stats->{slab_global_page_pool}, '>', 0, 'global page pool > 0'); cmp_ok($stats->{slab_reassign_chunk_rescues}, '>', 0, 'some chunk rescues happened'); } { my $hits = 0; for (1 .. $keycount) { print $sock "get nfoo$_\r\n"; my $body = scalar(<$sock>); my $expected = "VALUE nfoo$_ 0 11000\r\n$value\r\nEND\r\n"; if ($body =~ /^END/) { next; } else { $body .= scalar(<$sock>) . scalar(<$sock>); if ($body ne $expected) { die "Something terrible has happened: $expected\nBODY:\n$body\nDONETEST\n"; } $hits++; } } cmp_ok($hits, '>', 0, "fetched back $hits values after reassignment"); } $value = "A"x3000; for (1 .. $keycount) { print $sock "set ifoo$_ 0 0 3000 noreply\r\n$value\r\n"; } my $missing = 0; my $hits = 0; for (1 .. $keycount) { print $sock "get ifoo$_\r\n"; my $body = scalar(<$sock>); my $expected = "VALUE ifoo$_ 0 3000\r\n$value\r\nEND\r\n"; if ($body =~ /^END/) { $missing++; } else { $body .= scalar(<$sock>) . scalar(<$sock>); if ($body ne $expected) { print STDERR "Something terrible has happened: $expected\nBODY:\n$body\nDONETEST\n"; } else { $hits++; } } } #print STDERR "HITS: $hits, MISSES: $missing\n"; { my $stats = mem_stats($sock); cmp_ok($stats->{evictions}, '<', 2000, 'evictions were less than 2000'); # for ('evictions', 'reclaimed', 'curr_items', 'cmd_set', 'bytes') { # print STDERR "$_: ", $stats->{$_}, "\n"; # } } cmp_ok($hits, '>', 4000, 'were able to fetch back 2/3rds of 8k keys'); my $stats_done = mem_stats($sock); cmp_ok($stats_done->{slab_reassign_chunk_rescues}, '>', 0, 'some reassign chunk rescues happened'); # Reassign rescues won't happen here because the headers are of a different # size and we aren't moving pages out of that slab class #cmp_ok($stats_done->{slab_reassign_rescues}, '>', 0, 'some reassign rescues happened'); cmp_ok($stats_done->{slab_reassign_evictions_nomem}, '>', 0, 'some reassign evictions happened'); memcached-1.6.20/t/extstore-jbod.t0000664000175000017500000000403714340006077013657 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; use Data::Dumper qw/Dumper/; my $ext_path; my $ext_path2; if (!supports_extstore()) { plan skip_all => 'extstore not enabled'; exit 0; } $ext_path = "/tmp/extstore1.$$"; $ext_path2 = "/tmp/extstore2.$$"; my $server = new_memcached("-m 256 -U 0 -o ext_page_size=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path:64m,ext_path=$ext_path2:96m,slab_automove=1,ext_max_sleep=100000"); my $sock = $server->sock; my $value; { my @chars = ("C".."Z"); for (1 .. 20000) { $value .= $chars[rand @chars]; } } # fill some larger objects { # interleave sets with 0 ttl vs long ttl's. my $keycount = 3700; for (1 .. $keycount) { print $sock "set nfoo$_ 0 0 20000 noreply\r\n$value\r\n"; print $sock "set lfoo$_ 0 0 20000 noreply\r\n$value\r\n"; } # wait for a flush wait_ext_flush($sock); # delete half mem_get_is($sock, "nfoo1", $value); for (1 .. $keycount) { print $sock "delete lfoo$_ noreply\r\n"; } print $sock "lru_crawler crawl all\r\n"; <$sock>; sleep 10; # fetch # check extstore counters my $stats = mem_stats($sock); is($stats->{evictions}, 0, 'no RAM evictions'); cmp_ok($stats->{extstore_page_allocs}, '>', 0, 'at least one page allocated'); cmp_ok($stats->{extstore_objects_written}, '>', $keycount / 2, 'some objects written'); cmp_ok($stats->{extstore_bytes_written}, '>', length($value) * 2, 'some bytes written'); cmp_ok($stats->{get_extstore}, '>', 0, 'one object was fetched'); cmp_ok($stats->{extstore_objects_read}, '>', 0, 'one object read'); cmp_ok($stats->{extstore_bytes_read}, '>', length($value), 'some bytes read'); cmp_ok($stats->{extstore_page_reclaims}, '>', 1, 'at least two pages reclaimed'); } done_testing(); END { unlink $ext_path if $ext_path; unlink $ext_path2 if $ext_path2; } memcached-1.6.20/t/idle-timeout.t0000664000175000017500000000222614340006077013465 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More tests => 11; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; # start up a server with 10 maximum connections my $server = new_memcached("-o idle_timeout=3 -l 127.0.0.1"); my $sock = $server->sock; # Make sure we can talk to start with my $stats = mem_stats($sock); is($stats->{idle_kicks}, "0", "check stats initial"); isnt($sock->connected(), undef, "check connected"); # Make sure we don't timeout when active for (my $i = 0; $i < 6; $i++) { $stats = mem_stats($sock); isnt($stats->{version}, undef, "check active $i"); } $stats = mem_stats($sock); is($stats->{idle_kicks}, "0", "check stats 2"); # Make sure we do timeout when not sleep(10); mem_stats($sock); # Network activity, so socket code will see dead socket sleep(1); # we run SSL tests over TCP; hence IO::Socket::SSL returns # '' upon disconnecting with the server. if (enabled_tls_testing()) { is($sock->connected(),'', "check disconnected"); } else { is($sock->connected(),undef, "check disconnected"); } $sock = $server->sock; $stats = mem_stats($sock); isnt($stats->{idle_kicks}, 0, "check stats timeout"); memcached-1.6.20/t/00-startup.t0000775000175000017500000000412714340006077013010 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 21; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; eval { my $server = new_memcached(); ok($server, "started the server"); }; is($@, '', 'Basic startup works'); eval { my $server = new_memcached("-l fooble"); }; ok($@, "Died with illegal -l args"); eval { my $server = new_memcached("-l 127.0.0.1"); }; is($@,'', "-l 127.0.0.1 works"); eval { my $server = new_memcached('-C'); my $stats = mem_stats($server->sock, 'settings'); is('no', $stats->{'cas_enabled'}); }; is($@, '', "-C works"); eval { my $server = new_memcached('-b 8675'); my $stats = mem_stats($server->sock, 'settings'); is('8675', $stats->{'tcp_backlog'}); }; is($@, '', "-b works"); foreach my $val ('auto', 'ascii') { eval { my $server = new_memcached("-B $val"); my $stats = mem_stats($server->sock, 'settings'); ok($stats->{'binding_protocol'} =~ /$val/, "$val works"); }; is($@, '', "$val works"); } # For the binary test, we just verify it starts since we don't have an easy bin client. eval { my $server = new_memcached("-B binary"); }; is($@, '', "binary works"); eval { my $server = new_memcached("-vv -B auto"); }; is($@, '', "auto works"); eval { my $server = new_memcached("-vv -B ascii"); }; is($@, '', "ascii works"); # For the binary test, we just verify it starts since we don't have an easy bin client. eval { my $server = new_memcached("-vv -B binary"); }; is($@, '', "binary works"); # Should blow up with something invalid. eval { my $server = new_memcached("-B http"); }; ok($@, "Died with illegal -B arg."); # Maximum connections must be greater than 0. eval { my $server = new_memcached("-c 0"); }; ok($@, "Died with invalid maximum connections 0."); eval { my $server = new_memcached("-c -1"); }; ok($@, "Died with invalid maximum connections -1."); # Should not allow -t 0 eval { my $server = new_memcached("-t 0"); }; ok($@, "Died with illegal 0 thread count"); { my $exit_code = run_help(); is($exit_code, 0, "Help defaults are fine."); }; memcached-1.6.20/t/lru-maintainer.t0000664000175000017500000000727414340006077014023 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More tests => 226; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; # Regression test for underestimating the size of items after the large memory # change. my $server = new_memcached('-m 3 -o lru_maintainer,lru_crawler -l 127.0.0.1'); my $sock = $server->sock; my $keystub = "X"x200; for (1 .. 15000) { print $sock "set $keystub$_ 0 0 2 noreply\r\nok\r\n"; } # There's probably already an error on the wire, so we'll see that. $keystub .= "20001"; print $sock "set $keystub 0 0 2\r\nok\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key without OOM"); # Basic tests $server = new_memcached('-m 6 -o lru_maintainer,lru_crawler -l 127.0.0.1'); $sock = $server->sock; for (1 .. 10) { print $sock "set ifoo$_ 0 1 2\r\nok\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key"); } sleep 3; { my $stats = mem_stats($sock); is($stats->{reclaimed}, 10, "expired key automatically reclaimed"); } my $value = "B"x66560; print $sock "set canary 0 0 66560\r\n$value\r\n"; is(scalar <$sock>, "STORED\r\n", "stored canary key"); # Now flush the slab class with junk. for (my $key = 0; $key < 100; $key++) { if ($key == 30) { my $stats; for (0..2) { # Give the juggler some time to move. some platforms suffer at # this more than others (solaris amd64?) $stats = mem_stats($sock, "items"); if ($stats->{"items:31:moves_to_cold"} == 0) { sleep 1; next; } last; } isnt($stats->{"items:31:moves_to_cold"}, 0, "moved some items to cold"); # Items need two fetches to become active mem_get_is($sock, "canary", $value); mem_get_is($sock, "canary", $value); $stats = mem_stats($sock); # The maintainer thread needs to juggle a bit to actually rescue an # item. If it's slow we could evict after resuming setting. sleep 1; for (0..4) { my $s2 = mem_stats($sock); if ($s2->{lru_maintainer_juggles} - $stats->{lru_maintainer_juggles} < 5) { sleep 1; next; } last; } $stats = mem_stats($sock, "items"); isnt($stats->{"items:31:moves_to_warm"}, 0, "our canary moved to warm"); } print $sock "set key$key 0 0 66560\r\n$value\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key$key"); } { my $stats = mem_stats($sock); isnt($stats->{evictions}, 0, "some evictions happened"); use Data::Dumper qw/Dumper/; } # Key should've been saved to the WARM_LRU, and still exists. mem_get_is($sock, "canary", $value); # Test TEMP_LRU $server = new_memcached('-m 2 -o lru_maintainer,lru_crawler,temporary_ttl=61'); $sock = $server->sock; { my $stats = mem_stats($sock, "settings"); is($stats->{temp_lru}, "yes"); } print $sock "set canary 0 30 66560\r\n$value\r\n"; is(scalar <$sock>, "STORED\r\n", "stored temporary canary key"); { my $stats = mem_stats($sock, "items"); is($stats->{"items:31:number_hot"}, 0, "item did not go into hot LRU"); } # *Not* fetching the key, and flushing the slab class with junk. # Using keys with higher TTL's here. for (my $key = 0; $key < 100; $key++) { print $sock "set key$key 0 3600 66560\r\n$value\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key$key"); } { my $stats = mem_stats($sock, "items"); isnt($stats->{"items:31:evictions"}, 0, "some evictions happened"); isnt($stats->{"items:31:number_hot"}, 0, "high exptime items went into hot LRU"); is($stats->{"items:31:number_temp"}, 1, "still one item in temporary LRU"); } # Canary should still exist, even unfetched, because it's protected by # temp LRU mem_get_is($sock, "canary", $value); memcached-1.6.20/t/cacert.pem0000664000175000017500000000262414301776131012647 00000000000000-----BEGIN CERTIFICATE----- MIID8DCCAtigAwIBAgIJAOCrnjDZoOG/MA0GCSqGSIb3DQEBCwUAMIGLMSgwJgYD VQQDDB9UZXN0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5MQswCQYDVQQIDAJD QTELMAkGA1UEBhMCVVMxHDAaBgkqhkiG9w0BCQEWDXJvb3RAdGVzdC5jb20xDTAL BgNVBAoMBFRlc3QxGDAWBgNVBAsMD1Rlc3QgRGVwYXJ0bWVudDAgFw0yMDEwMjcw MzA0NTVaGA8yNTIwMDYyODAzMDQ1NVowgYsxKDAmBgNVBAMMH1Rlc3QgUm9vdCBD ZXJ0aWZpY2F0ZSBBdXRob3JpdHkxCzAJBgNVBAgMAkNBMQswCQYDVQQGEwJVUzEc MBoGCSqGSIb3DQEJARYNcm9vdEB0ZXN0LmNvbTENMAsGA1UECgwEVGVzdDEYMBYG A1UECwwPVGVzdCBEZXBhcnRtZW50MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB CgKCAQEAvz238GzKt1UpaxgIxv76hlty5hCZKmD5B952MCWBRi7OyYatl0sMjv38 pgsICIT68wGqQaTmV4W0XQQ54+NZ3o5ujJaDQX2kLs8x0sjuNkmt5Wt+orqdxO99 lb7f4hpKyGq0OGeqz4nBHCZeqEt37OLxUgGWQtKGVZI0X/m/m4LudmWwZpLgAp0w 5mY+FLaPavLoXQ95+f3htUzgRdzsFWMXi0piH/D4ua2i+ekajf8owxmR9AIKpAYY oV1J+XexlzVzXG1OPUEkGvbxnoDIHUoL6IM4i/QEI52UL0b+sVVV0fmJw08mkN95 XhW+OhS52lSBdqiC3/uRRF/g8/5nowIDAQABo1MwUTAdBgNVHQ4EFgQUcqmERx2+ c9d5Qd04od22AYhwY/AwHwYDVR0jBBgwFoAUcqmERx2+c9d5Qd04od22AYhwY/Aw DwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAFYdGLXwXTU4p/CIF bVRzS+RTEMc6cwd/CC+q0iVZT5Yfhu+MvdlaLMEimYTO44qu32hZHO6ovvSoSNJ1 fofv5crljHyyQY8GoZIq2jm7DcUyWJLuanqIcVXM9o0xR2CdOhvvDo/M0vRpR6EB ASZ7uV+w/tuc05YLdQOsXJyiXk80H7emJ0bRl1m/H2wxZRnL2jN2Iz1xeY8tGiP0 UU9x0hNS7eNzC1IdRUGVcfstyXznKs37F0ZyNHF1TOTZT80mdJxn0D1alVLqkiN3 RsIZpo1aZ0SShdtIx6luPU2wmGo5kLL2wN6Md18XSHViGA9dx2Mz00GxxDbiQl+F 6qzVDA== -----END CERTIFICATE----- memcached-1.6.20/t/proxy.t0000664000175000017500000001745314427543277012273 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use Carp qw(croak); use MemcachedTest; # TODO: to module? # or "gettimedrun" etc use Cwd; my $builddir = getcwd; if (!supports_proxy()) { plan skip_all => 'proxy not enabled'; exit 0; } # TODO: the lua file has hardcoded ports. any way to make this dynamic? # TODO: once basic tests are done, actually split out the instances rather # than the shared backend; validate keys go where they should be going. # FIXME: this listend on unix socket still. either need a manual runner or a # fix upstream. my @srv = (); for (2 .. 6) { my $srv = run_server("-p 1121$_", 11210 + $_); push(@srv, $srv); } #my $sock = $srv->sock; my $p_srv = new_memcached('-o proxy_config=./t/startfile.lua'); my $p_sock = $p_srv->sock; # hack to help me use T_MEMD_USE_DAEMON for proxy. #print STDERR "Sleeping\n"; #sleep 900; # cmds to test: # - noreply for main text commands? # meta: # me # mn # mg # ms # md # ma # - noreply? # stats # pass-thru? # incr/decr { print $p_sock "set /foo/num 0 0 1\r\n1\r\n"; is(scalar <$p_sock>, "STORED\r\n", "stored num"); mem_get_is($p_sock, "/foo/num", 1, "stored 1"); print $p_sock "incr /foo/num 1\r\n"; is(scalar <$p_sock>, "2\r\n", "+ 1 = 2"); mem_get_is($p_sock, "/foo/num", 2); print $p_sock "incr /foo/num 8\r\n"; is(scalar <$p_sock>, "10\r\n", "+ 8 = 10"); mem_get_is($p_sock, "/foo/num", 10); print $p_sock "decr /foo/num 1\r\n"; is(scalar <$p_sock>, "9\r\n", "- 1 = 9"); print $p_sock "decr /foo/num 9\r\n"; is(scalar <$p_sock>, "0\r\n", "- 9 = 0"); print $p_sock "decr /foo/num 5\r\n"; is(scalar <$p_sock>, "0\r\n", "- 5 = 0"); } # gat { # cache miss print $p_sock "gat 10 /foo/foo1\r\n"; is(scalar <$p_sock>, "END\r\n", "cache miss"); # set /foo/foo1 and /foo/foo2 (and should get it) print $p_sock "set /foo/foo1 0 2 7\r\nfooval1\r\n"; is(scalar <$p_sock>, "STORED\r\n", "stored foo"); print $p_sock "set /foo/foo2 0 2 7\r\nfooval2\r\n"; is(scalar <$p_sock>, "STORED\r\n", "stored /foo/foo2"); # get and touch it with cas print $p_sock "gats 10 /foo/foo1 /foo/foo2\r\n"; like(scalar <$p_sock>, qr/VALUE \/foo\/foo1 0 7 (\d+)\r\n/, "get and touch foo1 with cas regexp success"); is(scalar <$p_sock>, "fooval1\r\n","value"); like(scalar <$p_sock>, qr/VALUE \/foo\/foo2 0 7 (\d+)\r\n/, "get and touch foo2 with cas regexp success"); is(scalar <$p_sock>, "fooval2\r\n","value"); is(scalar <$p_sock>, "END\r\n", "end"); # get and touch it without cas print $p_sock "gat 10 /foo/foo1 /foo/foo2\r\n"; like(scalar <$p_sock>, qr/VALUE \/foo\/foo1 0 7\r\n/, "get and touch foo1 without cas regexp success"); is(scalar <$p_sock>, "fooval1\r\n","value"); like(scalar <$p_sock>, qr/VALUE \/foo\/foo2 0 7\r\n/, "get and touch foo2 without cas regexp success"); is(scalar <$p_sock>, "fooval2\r\n","value"); is(scalar <$p_sock>, "END\r\n", "end"); } # gets/cas { print $p_sock "add /foo/moo 0 0 6\r\nmooval\r\n"; is(scalar <$p_sock>, "STORED\r\n", "stored mooval"); mem_get_is($p_sock, "/foo/moo", "mooval"); # check-and-set (cas) failure case, try to set value with incorrect cas unique val print $p_sock "cas /foo/moo 0 0 6 0\r\nMOOVAL\r\n"; is(scalar <$p_sock>, "EXISTS\r\n", "check and set with invalid id"); # test "gets", grab unique ID print $p_sock "gets /foo/moo\r\n"; # VALUE moo 0 6 3084947704 # my @retvals = split(/ /, scalar <$p_sock>); my $data = scalar <$p_sock>; # grab data my $dot = scalar <$p_sock>; # grab dot on line by itself is($retvals[0], "VALUE", "get value using 'gets'"); my $unique_id = $retvals[4]; # clean off \r\n $unique_id =~ s/\r\n$//; ok($unique_id =~ /^\d+$/, "unique ID '$unique_id' is an integer"); # now test that we can store moo with the correct unique id print $p_sock "cas /foo/moo 0 0 6 $unique_id\r\nMOOVAL\r\n"; is(scalar <$p_sock>, "STORED\r\n"); mem_get_is($p_sock, "/foo/moo", "MOOVAL"); } # touch { print $p_sock "set /foo/t 0 2 6\r\nfooval\r\n"; is(scalar <$p_sock>, "STORED\r\n", "stored foo"); mem_get_is($p_sock, "/foo/t", "fooval"); # touch it print $p_sock "touch /foo/t 10\r\n"; is(scalar <$p_sock>, "TOUCHED\r\n", "touched foo"); # don't need to sleep/validate the touch worked. We're testing the # protocol, not the functionality. } # command endings # NOTE: memcached always allowed [\r]\n for single command lines, but payloads # (set/etc) require exactly \r\n as termination. # doc/protocol.txt has always specified \r\n for command/response. # Proxy is more strict than normal server in this case. { my $s = $srv[0]->sock; print $s "version\n"; like(<$s>, qr/VERSION/, "direct server version cmd with just newline"); print $p_sock "version\n"; like(<$p_sock>, qr/CLIENT_ERROR/, "proxy version cmd with just newline"); print $p_sock "version\r\n"; like(<$p_sock>, qr/VERSION/, "proxy version cmd with full CRLF"); } # set through proxy. { print $p_sock "set /foo/z 0 0 5\r\nhello\r\n"; is(scalar <$p_sock>, "STORED\r\n", "stored test value through proxy"); # ensure it's fetchable. mem_get_is($p_sock, "/foo/z", "hello"); # delete it. print $p_sock "delete /foo/z\r\n"; is(scalar <$p_sock>, "DELETED\r\n", "removed test value"); # ensure it's deleted. mem_get_is($p_sock, "/foo/z", undef); } # test add. { print $p_sock "add /foo/a 0 0 3\r\nmoo\r\n"; is(scalar <$p_sock>, "STORED\r\n", "add test value through proxy"); # ensure it's fetchable mem_get_is($p_sock, "/foo/a", "moo"); # check re-adding fails. print $p_sock "add /foo/a 0 0 3\r\ngoo\r\n"; is(scalar <$p_sock>, "NOT_STORED\r\n", "re-add fails"); # ensure we still hae the old value mem_get_is($p_sock, "/foo/a", "moo"); } # pipelined set. { my $str = "set /foo/k 0 0 5\r\nhello\r\n"; print $p_sock "$str$str$str$str$str"; is(scalar <$p_sock>, "STORED\r\n", "stored test value through proxy"); is(scalar <$p_sock>, "STORED\r\n", "stored test value through proxy"); is(scalar <$p_sock>, "STORED\r\n", "stored test value through proxy"); is(scalar <$p_sock>, "STORED\r\n", "stored test value through proxy"); is(scalar <$p_sock>, "STORED\r\n", "stored test value through proxy"); } # Load some keys through proxy. my $bdata = 'x' x 256000; { for (1..20) { print $p_sock "set /foo/a$_ 0 0 2\r\nhi\r\n"; is(scalar <$p_sock>, "STORED\r\n", "stored test value"); print $p_sock "set /bar/b$_ 0 0 2\r\nhi\r\n"; is(scalar <$p_sock>, "STORED\r\n", "stored test value"); } # load a couple larger values for (1..4) { print $p_sock "set /foo/big$_ 0 0 256000\r\n$bdata\r\n"; is(scalar <$p_sock>, "STORED\r\n", "stored big value"); } diag "set large values"; } # fetch through proxy. { for (1..20) { mem_get_is($p_sock, "/foo/a$_", "hi"); } diag "fetched small values"; mem_get_is($p_sock, "/foo/big1", $bdata); diag "fetched big value"; } sub run_server { my ($args, $port) = @_; my $exe = get_memcached_exe(); my $childpid = fork(); my $root = ''; $root = "-u root" if ($< == 0); # test build requires more privileges $args .= " -o relaxed_privileges"; my $cmd = "$builddir/timedrun 120 $exe $root $args"; unless($childpid) { exec $cmd; exit; # NOTREACHED } for (1..20) { my $conn = IO::Socket::INET->new(PeerAddr => "127.0.0.1:$port"); if ($conn) { return Memcached::Handle->new(pid => $childpid, conn => $conn, host => "127.0.0.1", port => $port); } select undef, undef, undef, 0.10; } croak "Failed to start server."; } done_testing(); memcached-1.6.20/t/getandtouch.t0000664000175000017500000000251714340006077013374 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More tests => 15; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; # cache miss print $sock "gat 10 foo1\r\n"; is(scalar <$sock>, "END\r\n", "cache miss"); # set foo1 and foo2 (and should get it) print $sock "set foo1 0 2 7\r\nfooval1\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); print $sock "set foo2 0 2 7\r\nfooval2\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo2"); # get and touch it with cas print $sock "gats 10 foo1 foo2\r\n"; ok(scalar <$sock> =~ /VALUE foo1 0 7 (\d+)\r\n/, "get and touch foo1 with cas regexp success"); is(scalar <$sock>, "fooval1\r\n","value"); ok(scalar <$sock> =~ /VALUE foo2 0 7 (\d+)\r\n/, "get and touch foo2 with cas regexp success"); is(scalar <$sock>, "fooval2\r\n","value"); is(scalar <$sock>, "END\r\n", "end"); # get and touch it without cas print $sock "gat 10 foo1 foo2\r\n"; ok(scalar <$sock> =~ /VALUE foo1 0 7\r\n/, "get and touch foo1 without cas regexp success"); is(scalar <$sock>, "fooval1\r\n","value"); ok(scalar <$sock> =~ /VALUE foo2 0 7\r\n/, "get and touch foo2 without cas regexp success"); is(scalar <$sock>, "fooval2\r\n","value"); is(scalar <$sock>, "END\r\n", "end"); sleep 2; mem_get_is($sock, "foo1", "fooval1"); mem_get_is($sock, "foo2", "fooval2"); memcached-1.6.20/t/binary-extstore.t0000775000175000017500000004257314340006077014237 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; use Data::Dumper qw/Dumper/; my $ext_path; if (!supports_extstore()) { plan skip_all => 'extstore not enabled'; exit 0; } $ext_path = "/tmp/extstore.$$"; my $server = new_memcached("-m 64 -U 0 -o ext_page_size=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path:64m,no_lru_crawler,slab_automove=0,ext_max_sleep=100000"); ok($server, "started the server"); # Based almost 100% off testClient.py which is: # Copyright (c) 2007 Dustin Sallings # Command constants use constant CMD_GET => 0x00; use constant CMD_SET => 0x01; use constant CMD_ADD => 0x02; use constant CMD_REPLACE => 0x03; use constant CMD_DELETE => 0x04; use constant CMD_INCR => 0x05; use constant CMD_DECR => 0x06; use constant CMD_QUIT => 0x07; use constant CMD_FLUSH => 0x08; use constant CMD_GETQ => 0x09; use constant CMD_NOOP => 0x0A; use constant CMD_VERSION => 0x0B; use constant CMD_GETK => 0x0C; use constant CMD_GETKQ => 0x0D; use constant CMD_APPEND => 0x0E; use constant CMD_PREPEND => 0x0F; use constant CMD_STAT => 0x10; use constant CMD_SETQ => 0x11; use constant CMD_ADDQ => 0x12; use constant CMD_REPLACEQ => 0x13; use constant CMD_DELETEQ => 0x14; use constant CMD_INCREMENTQ => 0x15; use constant CMD_DECREMENTQ => 0x16; use constant CMD_QUITQ => 0x17; use constant CMD_FLUSHQ => 0x18; use constant CMD_APPENDQ => 0x19; use constant CMD_PREPENDQ => 0x1A; use constant CMD_TOUCH => 0x1C; use constant CMD_GAT => 0x1D; use constant CMD_GATQ => 0x1E; use constant CMD_GATK => 0x23; use constant CMD_GATKQ => 0x24; # REQ and RES formats are divided even though they currently share # the same format, since they _could_ differ in the future. use constant REQ_PKT_FMT => "CCnCCnNNNN"; use constant RES_PKT_FMT => "CCnCCnNNNN"; use constant INCRDECR_PKT_FMT => "NNNNN"; use constant MIN_RECV_BYTES => length(pack(RES_PKT_FMT)); use constant REQ_MAGIC => 0x80; use constant RES_MAGIC => 0x81; my $mc = MC::Client->new; # Wait until all items have flushed sub wait_for_ext { my $sum = 1; while ($sum != 0) { my %s = $mc->stats("items"); $sum = 0; for my $key (keys %s) { if ($key =~ m/items:(\d+):number/) { # Ignore classes which can contain extstore items next if $1 < 3; $sum += $s{$key}; } } sleep 1 if $sum != 0; } } my $check = sub { my ($key, $orig_flags, $orig_val) = @_; my ($flags, $val, $cas) = $mc->get($key); is($flags, $orig_flags, "Flags is set properly"); ok($val eq $orig_val || $val == $orig_val, $val . " = " . $orig_val); }; my $set = sub { my ($key, $exp, $orig_flags, $orig_value) = @_; $mc->set($key, $orig_value, $orig_flags, $exp); $check->($key, $orig_flags, $orig_value); }; my $empty = sub { my $key = shift; my $rv =()= eval { $mc->get($key) }; is($rv, 0, "Didn't get a result from get"); ok($@->not_found, "We got a not found error when we expected one"); }; my $delete = sub { my ($key, $when) = @_; $mc->delete($key, $when); $empty->($key); }; my $value; my $bigvalue; { my @chars = ("C".."Z"); for (1 .. 20000) { $value .= $chars[rand @chars]; } for (1 .. 800000) { $bigvalue .= $chars[rand @chars]; } } # diag "small object"; $set->('x', 10, 19, "somevalue"); # check extstore counters { my %stats = $mc->stats(''); is($stats{extstore_objects_written}, 0); } # diag "Delete"; #$delete->('x'); # diag "Flush"; #$empty->('y'); # fill some larger objects { my $keycount = 1000; for (1 .. $keycount) { $set->("nfoo$_", 0, 19, $value); } # wait for a flush wait_for_ext(); # value returns for one flushed object. $check->('nfoo1', 19, $value); # check extstore counters my %stats = $mc->stats(''); cmp_ok($stats{extstore_page_allocs}, '>', 0, 'at least one page allocated'); cmp_ok($stats{extstore_objects_written}, '>', $keycount / 2, 'some objects written'); cmp_ok($stats{extstore_bytes_written}, '>', length($value) * 2, 'some bytes written'); cmp_ok($stats{get_extstore}, '>', 0, 'one object was fetched'); cmp_ok($stats{extstore_objects_read}, '>', 0, 'one object read'); cmp_ok($stats{extstore_bytes_read}, '>', length($value), 'some bytes read'); # Test multiget my $rv = $mc->get_multi(qw(nfoo2 nfoo3 noexist)); is($rv->{nfoo2}->[1], $value, 'multiget nfoo2'); is($rv->{nfoo3}->[1], $value, 'multiget nfoo2'); # Remove half of the keys for the next test. for (1 .. $keycount) { next unless $_ % 2 == 0; $delete->("nfoo$_"); } my %stats2 = $mc->stats(''); cmp_ok($stats{extstore_bytes_used}, '>', $stats2{extstore_bytes_used}, 'bytes used dropped after deletions'); cmp_ok($stats{extstore_objects_used}, '>', $stats2{extstore_objects_used}, 'objects used dropped after deletions'); is($stats2{badcrc_from_extstore}, 0, 'CRC checks successful'); # delete the rest for (1 .. $keycount) { next unless $_ % 2 == 1; $delete->("nfoo$_"); } } # check evictions and misses { my $keycount = 1000; for (1 .. $keycount) { $set->("mfoo$_", 0, 19, $value); } wait_for_ext(); for ($keycount .. ($keycount*3)) { $set->("mfoo$_", 0, 19, $value); } wait_for_ext(); # FIXME: Need to sample through a few values, or fix eviction to be # more accurate. On 32bit systems some pages unused to this point get # filled after the first few items, then the eviction algo pulls those # pages since they have the lowest version number, leaving older objects # in memory and evicting newer ones. for (1 .. ($keycount*3)) { next unless $_ % 100 == 0; eval { $mc->get("mfoo$_"); }; } my %s = $mc->stats(''); cmp_ok($s{extstore_objects_evicted}, '>', 0); cmp_ok($s{miss_from_extstore}, '>', 0); } # store and re-fetch a chunked value { my %stats = $mc->stats(''); $set->("bigvalue", 0, 0, $bigvalue); wait_for_ext(); $check->("bigvalue", 0, $bigvalue); my %stats2 = $mc->stats(''); cmp_ok($stats2{extstore_objects_written}, '>', $stats{extstore_objects_written}, "a large value flushed"); } # ensure ASCII can still fetch the chunked value. { my $ns = $server->new_sock; my %s1 = $mc->stats(''); mem_get_is($ns, "bigvalue", $bigvalue); print $ns "extstore recache_rate 1\r\n"; is(scalar <$ns>, "OK\r\n", "recache rate upped"); for (1..3) { mem_get_is($ns, "bigvalue", $bigvalue); $check->('bigvalue', 0, $bigvalue); } my %s2 = $mc->stats(''); cmp_ok($s2{recache_from_extstore}, '>', $s1{recache_from_extstore}, 'a new recache happened'); } done_testing(); END { unlink $ext_path if $ext_path; } # ###################################################################### # Test ends around here. # ###################################################################### package MC::Client; use strict; use warnings; use fields qw(socket); use IO::Socket::INET; sub new { my $self = shift; my ($s) = @_; $s = $server unless defined $s; my $sock = $s->sock; $self = fields::new($self); $self->{socket} = $sock; return $self; } sub build_command { my $self = shift; die "Not enough args to send_command" unless @_ >= 4; my ($cmd, $key, $val, $opaque, $extra_header, $cas) = @_; $extra_header = '' unless defined $extra_header; my $keylen = length($key); my $vallen = length($val); my $extralen = length($extra_header); my $datatype = 0; # field for future use my $reserved = 0; # field for future use my $totallen = $keylen + $vallen + $extralen; my $ident_hi = 0; my $ident_lo = 0; if ($cas) { $ident_hi = int($cas / 2 ** 32); $ident_lo = int($cas % 2 ** 32); } my $msg = pack(::REQ_PKT_FMT, ::REQ_MAGIC, $cmd, $keylen, $extralen, $datatype, $reserved, $totallen, $opaque, $ident_hi, $ident_lo); my $full_msg = $msg . $extra_header . $key . $val; return $full_msg; } sub send_command { my $self = shift; die "Not enough args to send_command" unless @_ >= 4; my ($cmd, $key, $val, $opaque, $extra_header, $cas) = @_; my $full_msg = $self->build_command($cmd, $key, $val, $opaque, $extra_header, $cas); my $sent = 0; my $data_len = length($full_msg); while ($sent < $data_len) { my $sent_bytes = $self->{socket}->syswrite($full_msg, $data_len - $sent > MemcachedTest::MAX_READ_WRITE_SIZE ? MemcachedTest::MAX_READ_WRITE_SIZE : ($data_len - $sent), $sent); last if ($sent_bytes <= 0); $sent += $sent_bytes; } die("Send failed: $!") unless $data_len; if($sent != length($full_msg)) { die("only sent $sent of " . length($full_msg) . " bytes"); } } sub flush_socket { my $self = shift; $self->{socket}->flush; } # Send a silent command and ensure it doesn't respond. sub send_silent { my $self = shift; die "Not enough args to send_silent" unless @_ >= 4; my ($cmd, $key, $val, $opaque, $extra_header, $cas) = @_; $self->send_command($cmd, $key, $val, $opaque, $extra_header, $cas); $self->send_command(::CMD_NOOP, '', '', $opaque + 1); my ($ropaque, $data) = $self->_handle_single_response; Test::More::is($ropaque, $opaque + 1); } sub silent_mutation { my $self = shift; my ($cmd, $key, $value) = @_; $empty->($key); my $extra = pack "NN", 82, 0; $mc->send_silent($cmd, $key, $value, 7278552, $extra, 0); $check->($key, 82, $value); } sub _handle_single_response { my $self = shift; my $myopaque = shift; my $hdr = ""; while(::MIN_RECV_BYTES - length($hdr) > 0) { $self->{socket}->sysread(my $response, ::MIN_RECV_BYTES - length($hdr)); $hdr .= $response; } Test::More::is(length($hdr), ::MIN_RECV_BYTES, "Expected read length"); my ($magic, $cmd, $keylen, $extralen, $datatype, $status, $remaining, $opaque, $ident_hi, $ident_lo) = unpack(::RES_PKT_FMT, $hdr); Test::More::is($magic, ::RES_MAGIC, "Got proper response magic"); my $cas = ($ident_hi * 2 ** 32) + $ident_lo; return ($opaque, '', $cas, 0) if($remaining == 0); # fetch the value my $rv=""; while($remaining - length($rv) > 0) { $self->{socket}->sysread(my $buf, $remaining - length($rv)); $rv .= $buf; } if(length($rv) != $remaining) { my $found = length($rv); die("Expected $remaining bytes, got $found"); } if (defined $myopaque) { Test::More::is($opaque, $myopaque, "Expected opaque"); } else { Test::More::pass("Implicit pass since myopaque is undefined"); } if ($status) { die MC::Error->new($status, $rv); } return ($opaque, $rv, $cas, $keylen); } sub _do_command { my $self = shift; die unless @_ >= 3; my ($cmd, $key, $val, $extra_header, $cas) = @_; $extra_header = '' unless defined $extra_header; my $opaque = int(rand(2**32)); $self->send_command($cmd, $key, $val, $opaque, $extra_header, $cas); my (undef, $rv, $rcas) = $self->_handle_single_response($opaque); return ($rv, $rcas); } sub _incrdecr_header { my $self = shift; my ($amt, $init, $exp) = @_; my $amt_hi = int($amt / 2 ** 32); my $amt_lo = int($amt % 2 ** 32); my $init_hi = int($init / 2 ** 32); my $init_lo = int($init % 2 ** 32); my $extra_header = pack(::INCRDECR_PKT_FMT, $amt_hi, $amt_lo, $init_hi, $init_lo, $exp); return $extra_header; } sub _incrdecr_cas { my $self = shift; my ($cmd, $key, $amt, $init, $exp) = @_; my ($data, $rcas) = $self->_do_command($cmd, $key, '', $self->_incrdecr_header($amt, $init, $exp)); my $header = substr $data, 0, 8, ''; my ($resp_hi, $resp_lo) = unpack "NN", $header; my $resp = ($resp_hi * 2 ** 32) + $resp_lo; return $resp, $rcas; } sub _incrdecr { my $self = shift; my ($v, $c) = $self->_incrdecr_cas(@_); return $v } sub silent_incrdecr { my $self = shift; my ($cmd, $key, $amt, $init, $exp) = @_; my $opaque = 8275753; $mc->send_silent($cmd, $key, '', $opaque, $mc->_incrdecr_header($amt, $init, $exp)); } sub stats { my $self = shift; my $key = shift; my $cas = 0; my $opaque = int(rand(2**32)); $self->send_command(::CMD_STAT, $key, '', $opaque, '', $cas); my %rv = (); my $found_key = ''; my $found_val = ''; do { my ($op, $data, $cas, $keylen) = $self->_handle_single_response($opaque); if($keylen > 0) { $found_key = substr($data, 0, $keylen); $found_val = substr($data, $keylen); $rv{$found_key} = $found_val; } else { $found_key = ''; } } while($found_key ne ''); return %rv; } sub get { my $self = shift; my $key = shift; my ($rv, $cas) = $self->_do_command(::CMD_GET, $key, '', ''); my $header = substr $rv, 0, 4, ''; my $flags = unpack("N", $header); return ($flags, $rv, $cas); } sub get_multi { my $self = shift; my @keys = @_; for (my $i = 0; $i < @keys; $i++) { $self->send_command(::CMD_GETQ, $keys[$i], '', $i, '', 0); } my $terminal = @keys + 10; $self->send_command(::CMD_NOOP, '', '', $terminal); my %return; while (1) { my ($opaque, $data) = $self->_handle_single_response; last if $opaque == $terminal; my $header = substr $data, 0, 4, ''; my $flags = unpack("N", $header); $return{$keys[$opaque]} = [$flags, $data]; } return %return if wantarray; return \%return; } sub touch { my $self = shift; my ($key, $expire) = @_; my $extra_header = pack "N", $expire; my $cas = 0; return $self->_do_command(::CMD_TOUCH, $key, '', $extra_header, $cas); } sub gat { my $self = shift; my $key = shift; my $expire = shift; my $extra_header = pack "N", $expire; my ($rv, $cas) = $self->_do_command(::CMD_GAT, $key, '', $extra_header); my $header = substr $rv, 0, 4, ''; my $flags = unpack("N", $header); return ($flags, $rv, $cas); } sub version { my $self = shift; return $self->_do_command(::CMD_VERSION, '', ''); } sub flush { my $self = shift; return $self->_do_command(::CMD_FLUSH, '', ''); } sub add { my $self = shift; my ($key, $val, $flags, $expire) = @_; my $extra_header = pack "NN", $flags, $expire; my $cas = 0; return $self->_do_command(::CMD_ADD, $key, $val, $extra_header, $cas); } sub set { my $self = shift; my ($key, $val, $flags, $expire, $cas) = @_; my $extra_header = pack "NN", $flags, $expire; return $self->_do_command(::CMD_SET, $key, $val, $extra_header, $cas); } sub _append_prepend { my $self = shift; my ($cmd, $key, $val, $cas) = @_; return $self->_do_command($cmd, $key, $val, '', $cas); } sub replace { my $self = shift; my ($key, $val, $flags, $expire) = @_; my $extra_header = pack "NN", $flags, $expire; my $cas = 0; return $self->_do_command(::CMD_REPLACE, $key, $val, $extra_header, $cas); } sub delete { my $self = shift; my ($key) = @_; return $self->_do_command(::CMD_DELETE, $key, ''); } sub incr { my $self = shift; my ($key, $amt, $init, $exp) = @_; $amt = 1 unless defined $amt; $init = 0 unless defined $init; $exp = 0 unless defined $exp; return $self->_incrdecr(::CMD_INCR, $key, $amt, $init, $exp); } sub incr_cas { my $self = shift; my ($key, $amt, $init, $exp) = @_; $amt = 1 unless defined $amt; $init = 0 unless defined $init; $exp = 0 unless defined $exp; return $self->_incrdecr_cas(::CMD_INCR, $key, $amt, $init, $exp); } sub decr { my $self = shift; my ($key, $amt, $init, $exp) = @_; $amt = 1 unless defined $amt; $init = 0 unless defined $init; $exp = 0 unless defined $exp; return $self->_incrdecr(::CMD_DECR, $key, $amt, $init, $exp); } sub noop { my $self = shift; return $self->_do_command(::CMD_NOOP, '', ''); } package MC::Error; use strict; use warnings; use constant ERR_UNKNOWN_CMD => 0x81; use constant ERR_NOT_FOUND => 0x1; use constant ERR_EXISTS => 0x2; use constant ERR_TOO_BIG => 0x3; use constant ERR_EINVAL => 0x4; use constant ERR_NOT_STORED => 0x5; use constant ERR_DELTA_BADVAL => 0x6; use overload '""' => sub { my $self = shift; return "Memcache Error ($self->[0]): $self->[1]"; }; sub new { my $class = shift; my $error = [@_]; my $self = bless $error, (ref $class || $class); return $self; } sub not_found { my $self = shift; return $self->[0] == ERR_NOT_FOUND; } sub exists { my $self = shift; return $self->[0] == ERR_EXISTS; } sub too_big { my $self = shift; return $self->[0] == ERR_TOO_BIG; } sub delta_badval { my $self = shift; return $self->[0] == ERR_DELTA_BADVAL; } sub einval { my $self = shift; return $self->[0] == ERR_EINVAL; } # vim: filetype=perl memcached-1.6.20/t/multiversioning.t0000775000175000017500000000355414340006077014332 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 13; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $sock2 = $server->new_sock; ok($sock != $sock2, "have two different connections open"); # set large value my $size = 256 * 1024; # 256 kB my $bigval = "0123456789abcdef" x ($size / 16); $bigval =~ s/^0/\[/; $bigval =~ s/f$/\]/; my $bigval2 = uc($bigval); print $sock "set big 0 0 $size\r\n$bigval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "big", $bigval, "big value got correctly"); print $sock "get big\r\n"; my $buf; my $read = 0; my $to_read = $size / 2; while ($read < $to_read) { my $read_bytes = $sock->sysread($buf, ($to_read - $read > MemcachedTest::MAX_READ_WRITE_SIZE ? MemcachedTest::MAX_READ_WRITE_SIZE : $to_read - $read), $read); last if ($read_bytes <= 0); $read += $read_bytes; } is($read, $size / 2, "read half the answer back"); like($buf, qr/VALUE big/, "buf has big value header in it"); like($buf, qr/abcdef/, "buf has some data in it"); unlike($buf, qr/abcde\]/, "buf doesn't yet close"); # sock2 interrupts (maybe sock1 is slow) and deletes stuff: print $sock2 "delete big\r\n"; is(scalar <$sock2>, "DELETED\r\n", "deleted big from sock2 while sock1's still reading it"); mem_get_is($sock2, "big", undef, "nothing from sock2 now. gone from namespace."); print $sock2 "set big 0 0 $size\r\n$bigval2\r\n"; is(scalar <$sock2>, "STORED\r\n", "stored big w/ val2"); mem_get_is($sock2, "big", $bigval2, "big value2 got correctly"); # sock1 resumes reading... $buf .= <$sock>; $buf .= <$sock>; like($buf, qr/abcde\]/, "buf now closes"); # and if sock1 reads again, it's the uppercase version: mem_get_is($sock, "big", $bigval2, "big value2 got correctly from sock1"); memcached-1.6.20/t/watcher_connid.t0000664000175000017500000000401014402177543014052 00000000000000#!/usr/bin/env perl # Test for adding connection id to the output when watching fetchers # and mutations. # Note that this test relies on the order of connection establishments. This # could be improved if there's a way for a client to retrieve its connection id. use strict; use warnings; use Socket qw/SO_RCVBUF/; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; plan tests => 4; my $server = new_memcached('-m 60 -o watcher_logbuf_size=8'); my $client_first = $server->sock; my $stats; # get the first client's connection id print $client_first "stats conns\r\n"; while (<$client_first>) { last if /^(\.|END)/; $stats = $_; } my $cfd_first =(split(':', $stats))[0]; $cfd_first =~ s/[^0-9]//g; # start watching fetchers and mutations my $watcher = $server->new_sock; print $watcher "watch fetchers mutations\n"; my $res = <$watcher>; is($res, "OK\r\n", "watching enabled for fetchers and mutations"); # first client does a set, which will result in a get and a set print $client_first "set foo 0 0 5 noreply\r\nhello\r\n"; # ensure client's connection id is correct $res = <$watcher>; print $res; like($res, qr/ts=\d+\.\d+\ gid=\d+ type=item_get key=foo status=not_found clsid=\d+ cfd=$cfd_first/, "Saw a miss with the connection id $cfd_first"); $res = <$watcher>; print $res; like($res, qr/ts=\d+\.\d+\ gid=\d+ type=item_store key=foo status=stored cmd=set ttl=\d+ clsid=\d+ cfd=$cfd_first/, "Saw a set with the connection id $cfd_first"); # get the second client's connection id my $client_second = $server->new_sock; print $client_second "stats conns\r\n"; while (<$client_second>) { last if /^(\.|END)/; $stats = $_; } my $cfd_second =(split(':', $stats))[0]; $cfd_second =~ s/[^0-9]//g; # second client does a get print $client_second "get foo\r\n"; # now we should see second client's connection id $res = <$watcher>; print $res; like($res, qr/ts=\d+\.\d+\ gid=\d+ type=item_get key=foo status=found clsid=\d+ cfd=$cfd_second/, "Saw a get with the connection id $cfd_second"); memcached-1.6.20/t/server_crt.pem0000664000175000017500000001040514301776131013560 00000000000000Certificate: Data: Version: 3 (0x2) Serial Number: 78:f7:9b:75:a7:9d:83:12:a5:c7:a0:b6:af:87:da:c3:d9:32:c2:d6 Signature Algorithm: sha256WithRSAEncryption Issuer: CN = Test Root Certificate Authority, ST = CA, C = US, emailAddress = root@test.com, O = Test, OU = Test Department Validity Not Before: Oct 27 03:09:35 2020 GMT Not After : Jun 28 03:09:35 2520 GMT Subject: C = US, ST = CA, O = Test, OU = Subunit of Test Organization, CN = test.com, emailAddress = root@test.com Subject Public Key Info: Public Key Algorithm: rsaEncryption RSA Public-Key: (2048 bit) Modulus: 00:c8:9f:ff:4d:a0:6e:9e:ab:6f:0f:5b:7a:67:b7: 2d:0b:eb:69:6b:9f:19:7a:6e:f5:b2:91:50:71:d4: b4:42:84:b9:e0:8c:98:61:89:2d:90:c2:0d:68:d4: ea:1c:6f:6d:d3:28:52:29:04:a1:4d:28:8e:38:35: 98:1b:5b:f3:c7:da:41:17:83:c8:d5:32:40:7e:90: bc:69:88:29:96:93:b4:d1:45:65:ac:7c:88:4c:54: dc:b0:b1:06:82:7e:0d:d3:a6:2d:50:e0:cd:6b:0b: c3:74:c4:96:8c:af:87:34:d7:3b:d7:33:60:e3:16: 99:01:06:5e:93:77:8b:6a:c3:3f:ce:9f:e0:44:3c: bc:b6:bc:e8:65:b3:72:94:ee:e4:99:6c:5f:a9:43: e4:0a:8d:13:38:48:dd:08:9c:51:6d:d6:d3:6b:dc: 44:b1:10:0f:7d:87:97:fc:ab:41:e5:11:28:b2:9b: e1:4b:8d:64:94:ee:3e:5f:b5:9a:03:ac:64:e1:b8: 3c:51:78:05:b9:98:f8:41:0b:36:7f:1e:76:a2:6a: 51:75:2d:e2:fa:0d:00:d2:b9:96:50:eb:ad:33:c3: ab:8c:ce:49:09:82:7f:69:77:b7:38:70:90:e7:16: 9c:6b:f2:c0:7e:61:ab:c4:34:04:aa:38:dc:4a:00: 50:ed Exponent: 65537 (0x10001) X509v3 extensions: X509v3 Subject Alternative Name: DNS:test.com, DNS:alt.test.com Signature Algorithm: sha256WithRSAEncryption 0f:ac:cb:a5:b2:13:63:3a:e7:f4:59:a6:ec:ad:ef:2e:61:5d: 16:23:df:fb:a4:24:75:60:d4:fe:5a:d6:ed:f9:a7:a4:9d:49: e0:1e:c6:e6:10:8d:d2:de:90:54:d4:c6:a8:e9:99:7b:62:c4: b5:86:9f:19:96:cb:96:93:79:47:81:48:bf:32:20:45:6f:00: 02:76:3f:1f:d5:3a:0b:ac:9e:b7:13:14:6f:b6:27:ad:34:d5: fa:82:5c:c6:1a:b4:4f:36:7b:e6:03:6d:4f:85:ce:43:42:d3: d3:7d:b4:7e:d1:dc:3b:27:31:94:d4:0a:08:ba:67:ec:e0:75: 63:4a:48:b0:01:c7:90:2d:da:2e:c9:ef:c7:8a:20:76:75:89: b5:cf:dc:a3:00:07:c0:26:73:89:00:63:ce:cf:7b:6e:95:c9: 5b:5a:d9:2a:0c:d5:96:61:9e:dd:b5:db:88:61:45:df:29:c1: de:34:e6:fa:25:23:2c:4e:71:c9:ba:d1:53:f9:38:28:6b:5a: 47:a4:db:91:2d:54:3f:35:e4:a6:b6:1d:d1:7b:f9:c8:1a:35: 71:1d:7d:94:2e:53:22:d8:e1:ca:93:fa:e5:c4:48:cd:ee:29: 4a:65:71:2c:9a:ff:98:6f:48:25:2c:1a:90:14:4f:37:6e:e6: 87:1e:f8:f4 -----BEGIN CERTIFICATE----- MIIDwzCCAqugAwIBAgIUePebdaedgxKlx6C2r4faw9kywtYwDQYJKoZIhvcNAQEL BQAwgYsxKDAmBgNVBAMMH1Rlc3QgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkx CzAJBgNVBAgMAkNBMQswCQYDVQQGEwJVUzEcMBoGCSqGSIb3DQEJARYNcm9vdEB0 ZXN0LmNvbTENMAsGA1UECgwEVGVzdDEYMBYGA1UECwwPVGVzdCBEZXBhcnRtZW50 MCAXDTIwMTAyNzAzMDkzNVoYDzI1MjAwNjI4MDMwOTM1WjCBgTELMAkGA1UEBhMC VVMxCzAJBgNVBAgMAkNBMQ0wCwYDVQQKDARUZXN0MSUwIwYDVQQLDBxTdWJ1bml0 IG9mIFRlc3QgT3JnYW5pemF0aW9uMREwDwYDVQQDDAh0ZXN0LmNvbTEcMBoGCSqG SIb3DQEJARYNcm9vdEB0ZXN0LmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCC AQoCggEBAMif/02gbp6rbw9beme3LQvraWufGXpu9bKRUHHUtEKEueCMmGGJLZDC DWjU6hxvbdMoUikEoU0ojjg1mBtb88faQReDyNUyQH6QvGmIKZaTtNFFZax8iExU 3LCxBoJ+DdOmLVDgzWsLw3TEloyvhzTXO9czYOMWmQEGXpN3i2rDP86f4EQ8vLa8 6GWzcpTu5JlsX6lD5AqNEzhI3QicUW3W02vcRLEQD32Hl/yrQeURKLKb4UuNZJTu Pl+1mgOsZOG4PFF4BbmY+EELNn8edqJqUXUt4voNANK5llDrrTPDq4zOSQmCf2l3 tzhwkOcWnGvywH5hq8Q0BKo43EoAUO0CAwEAAaMlMCMwIQYDVR0RBBowGIIIdGVz dC5jb22CDGFsdC50ZXN0LmNvbTANBgkqhkiG9w0BAQsFAAOCAQEAD6zLpbITYzrn 9Fmm7K3vLmFdFiPf+6QkdWDU/lrW7fmnpJ1J4B7G5hCN0t6QVNTGqOmZe2LEtYaf GZbLlpN5R4FIvzIgRW8AAnY/H9U6C6yetxMUb7YnrTTV+oJcxhq0TzZ75gNtT4XO Q0LT0320ftHcOycxlNQKCLpn7OB1Y0pIsAHHkC3aLsnvx4ogdnWJtc/cowAHwCZz iQBjzs97bpXJW1rZKgzVlmGe3bXbiGFF3ynB3jTm+iUjLE5xybrRU/k4KGtaR6Tb kS1UPzXkprYd0Xv5yBo1cR19lC5TItjhypP65cRIze4pSmVxLJr/mG9IJSwakBRP N27mhx749A== -----END CERTIFICATE----- memcached-1.6.20/t/line-lengths.t0000775000175000017500000000101014340006077013446 00000000000000#!/usr/bin/env perl use strict; use FindBin qw($Bin); our @files; BEGIN { chdir "$Bin/.." or die; @files = ( "doc/protocol.txt" ); } use Test::More tests => scalar(@files); foreach my $f (@files) { open(my $fh, $f) or die("Can't open $f"); my @long_lines = (); my $line_number = 0; while(<$fh>) { $line_number++; if(length($_) > 80) { push(@long_lines, $line_number); } } close($fh); ok(@long_lines == 0, "$f has a long lines: @long_lines"); } memcached-1.6.20/t/shutdown.t0000664000175000017500000000252014340006077012734 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; # Disabled shutdown (default) { my $server = new_memcached(); my $sock = $server->sock; print $sock "shutdown\r\n"; is(scalar <$sock>, "ERROR: shutdown not enabled\r\n", "error when shutdown is not enabled"); } # Shutdown command error { my$server = new_memcached("-A"); my $sock = $server->sock; print $sock "shutdown foo\r\n"; like(scalar <$sock>, qr/CLIENT_ERROR/, "rejected invalid shutdown mode"); } # Normal shutdown { my $server = new_memcached("-A"); my $sock = $server->sock; print $sock "version\r\n"; like(scalar <$sock>, qr/VERSION/, "server is initially alive"); print $sock "shutdown\r\n"; still_going($server); } # Graceful shutdown { my $server = new_memcached("-A"); my $sock = $server->sock; print $sock "version\r\n"; like(scalar <$sock>, qr/VERSION/, "server is initially alive"); print $sock "shutdown graceful\r\n"; still_going($server); } sub still_going { my $server = shift; for (1..10) { if ($server->is_running) { sleep 1; } else { ok(!$server->is_running, "server stopped"); return; } } ok(0, "server failed to stop"); } done_testing(); memcached-1.6.20/t/proxyustats.t0000664000175000017500000001421014427543277013523 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use Carp qw(croak); use MemcachedTest; use IO::Select; use IO::Socket qw(AF_INET SOCK_STREAM); # TODO: possibly... set env var to a generated temp filename before starting # the server so we can pass that in? my $configfile = "/tmp/proxyustats.lua"; if (!supports_proxy()) { plan skip_all => 'proxy not enabled'; exit 0; } # Set up some server sockets. sub mock_server { my $port = shift; my $srv = IO::Socket->new( Domain => AF_INET, Type => SOCK_STREAM, Proto => 'tcp', LocalHost => '127.0.0.1', LocalPort => $port, ReusePort => 1, Listen => 5) || die "IO::Socket: $@"; return $srv; } sub accept_backend { my $srv = shift; my $be = $srv->accept(); $be->autoflush(1); ok(defined $be, "mock backend created"); like(<$be>, qr/version/, "received version command"); print $be "VERSION 1.0.0-mock\r\n"; return $be; } # Put a version command down the pipe to ensure the socket is clear. # client version commands skip the proxy code sub check_version { my $ps = shift; print $ps "version\r\n"; like(<$ps>, qr/VERSION /, "version received"); } # A single line containing prefix, start ustat and end ustat index. sub write_config { my $cmd = shift; open(my $fh, "> $configfile") or die "Couldn't overwrite $configfile: $!"; print $fh $cmd; close($fh); } sub wait_reload { my $w = shift; like(<$w>, qr/ts=(\S+) gid=\d+ type=proxy_conf status=start/, "reload started"); like(<$w>, qr/ts=(\S+) gid=\d+ type=proxy_conf status=done/, "reload completed"); } my ($p_srv, $ps, $watcher); sub restart_memcached { if ($p_srv) { $p_srv->stop(); } write_config('return "a 1 0"'); $p_srv = new_memcached('-o proxy_config=./t/proxyustats.lua'); $ps = $p_srv->sock; $ps->autoflush(1); $watcher = $p_srv->new_sock; print $watcher "watch proxyevents\n"; is(<$watcher>, "OK\r\n", "watcher enabled"); } diag "testing failure to start"; write_config("invalid"); eval { $p_srv = new_memcached('-o proxy_config=./t/proxyustats.lua'); }; ok($@ && $@ =~ m/Failed to connect/, "server successfully not started"); restart_memcached(); subtest 'succeeded to allocate 1024 ustats' => sub { my $pfx = "a"; my $first = 1; my $last = 1024; write_config('return "' . $pfx . ' ' . $first . ' ' . $last . '"'); $p_srv->reload(); wait_reload($watcher); my $stats = mem_stats($ps, 'proxy'); for my $i ($first..$last) { my $ustat = "user_" . $pfx . $i; is($stats->{$ustat}, 0, $ustat . " found"); } }; subtest 'failed to allocate 1025 ustats' => sub { my $pfx = "a"; my $first = 1025; my $last = 1025; write_config('return "' . $pfx . ' ' . $first . ' ' . $last . '"'); $p_srv->reload(); unlike(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_conf status=start/, "reload not started"); unlike(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_conf status=done/, "reload not completed"); restart_memcached(); }; subtest 'failed to allocate ustat at index 0' => sub { my $pfx = "a"; my $first = 0; my $last = 0; write_config('return "' . $pfx . ' ' . $first . ' ' . $last . '"'); $p_srv->reload(); unlike(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_conf status=start/, "reload not started"); unlike(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_conf status=done/, "reload not completed"); restart_memcached(); }; subtest 'succeeded to allocate ustat at 1024 only' => sub { # restart memcached to clear any ustats. restart_memcached(); my $pfx = "a"; my $first = 1024; my $last = 1024; write_config('return "' . $pfx . ' ' . $first . ' ' . $last . '"'); $p_srv->reload(); wait_reload($watcher); my $stats = mem_stats($ps, 'proxy'); while (my ($ustat, $value) = each %{$stats}) { if (index($ustat, "user_") == 0) { is($ustat, "user_a1024", "user_a1024 found"); } } }; subtest 'ustats incr/decr and perseverance over reload' => sub { # restart memcached to clear any ustats. restart_memcached(); my $pfx = "a"; my $first = 1; my $last = 3; write_config('return "' . $pfx . ' ' . $first . ' ' . $last . '"'); $p_srv->reload(); wait_reload($watcher); print $ps "mg 1\r\n"; is(scalar <$ps>, "HD\r\n", "mg 1 hit"); print $ps "mg 2\r\n"; is(scalar <$ps>, "HD\r\n", "mg 2 hit"); print $ps "mg 2\r\n"; is(scalar <$ps>, "HD\r\n", "mg 2 hit"); my $stats = mem_stats($ps, 'proxy'); is($stats->{user_a1}, 1, "user_a1 is 1"); is($stats->{user_a2}, 4, "user_a2 is 4"); is($stats->{user_a3}, 0, "user_a3 is 0"); $pfx = "b"; $first = 2; $last = 4; write_config('return "' . $pfx . ' ' . $first . ' ' . $last . '"'); $p_srv->reload(); wait_reload($watcher); # subtract 2 at idx 2. print $ps "mg -2\r\n"; is(scalar <$ps>, "HD\r\n", "mg -2 hit"); $stats = mem_stats($ps, 'proxy'); is($stats->{user_a1}, 1, "user_a1 is 1"); is($stats->{user_b2}, 2, "user_b2 is 2"); is($stats->{user_b3}, 0, "user_b3 is 0"); is($stats->{user_b4}, 0, "user_b4 is 0"); }; subtest 'failed to allocate ustat longer than 128 chars' => sub { my $pfx = '*' x 128; my $first = 1; my $last = 1; write_config('return "' . $pfx . ' ' . $first . ' ' . $last . '"'); $p_srv->reload(); unlike(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_conf status=start/, "reload not started"); unlike(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_conf status=done/, "reload not completed"); restart_memcached(); }; subtest 'negative ustat value underflow' => sub { # restart memcached to clear any ustats. restart_memcached(); my $pfx = "a"; my $first = 1; my $last = 1; write_config('return "' . $pfx . ' ' . $first . ' ' . $last . '"'); $p_srv->reload(); wait_reload($watcher); print $ps "mg -1\r\n"; is(scalar <$ps>, "HD\r\n", "mg -1 hit"); my $stats = mem_stats($ps, 'proxy'); isnt($stats->{user_a1}, -1, "user_a1 is not -1"); }; done_testing(); END { unlink $configfile; } memcached-1.6.20/t/touch.t0000775000175000017500000000073514340006077012214 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 4; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; # set foo (and should get it) print $sock "set foo 0 2 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", "fooval"); # touch it print $sock "touch foo 10\r\n"; is(scalar <$sock>, "TOUCHED\r\n", "touched foo"); sleep 2; mem_get_is($sock, "foo", "fooval"); memcached-1.6.20/t/proxyunits.t0000664000175000017500000010434214427543277013350 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use Carp qw(croak); use MemcachedTest; use IO::Socket qw(AF_INET SOCK_STREAM); use IO::Select; if (!supports_proxy()) { plan skip_all => 'proxy not enabled'; exit 0; } # Set up some server sockets. sub mock_server { my $port = shift; my $srv = IO::Socket->new( Domain => AF_INET, Type => SOCK_STREAM, Proto => 'tcp', LocalHost => '127.0.0.1', LocalPort => $port, ReusePort => 1, Listen => 5) || die "IO::Socket: $@"; return $srv; } # Accept and validate a new backend connection. sub accept_backend { my $srv = shift; my $be = $srv->accept(); $be->autoflush(1); ok(defined $be, "mock backend created"); like(<$be>, qr/version/, "received version command"); print $be "VERSION 1.0.0-mock\r\n"; return $be; } note("Initialization:" . __LINE__); my @mocksrvs = (); #diag "making mock servers"; for my $port (11411, 11412, 11413) { my $srv = mock_server($port); ok(defined $srv, "mock server created"); push(@mocksrvs, $srv); } my $p_srv = new_memcached('-o proxy_config=./t/proxyunits.lua'); my $ps = $p_srv->sock; $ps->autoflush(1); # set up server backend sockets. my @mbe = (); #diag "accepting mock backends"; for my $msrv (@mocksrvs) { my $be = accept_backend($msrv); push(@mbe, $be); } # Put a version command down the pipe to ensure the socket is clear. # client version commands skip the proxy code sub check_version { my $ps = shift; print $ps "version\r\n"; like(<$ps>, qr/VERSION /, "version received"); } # Send a touch command to all backends, and verify response. # This makes sure socket buffers are clean between tests. sub check_sanity { my $ps = shift; my $cmd = "touch /sanity/a 50\r\n"; print $ps $cmd; foreach my $be (@mbe) { is(scalar <$be>, $cmd, "sanity check: touch cmd received"); print $be "TOUCHED\r\n"; } is(scalar <$ps>, "TOUCHED\r\n", "sanity check: TOUCHED response received."); } # $ps_send : request to proxy # $be_recv : ref to a hashmap from be index to an array of received requests for validation. # $be_send : ref to a hashmap from be index to an array of responses to proxy. # $ps_recv : ref to response returned by proxy # backends in $be_recv and $be_send are vistied by looping through the @mbe. sub proxy_test { my %args = @_; my $ps_send = $args{ps_send}; my $be_recv = $args{be_recv} // {}; my $be_send = $args{be_send} // {}; my $ps_recv = $args{ps_recv} // []; # sends request to proxy print $ps $ps_send; # verify all backends received request foreach my $idx (keys @mbe) { if (exists $be_recv->{$idx}) { my $be = $mbe[$idx]; foreach my $recv (@{$be_recv->{$idx}}) { is(scalar <$be>, $recv, "be " . $idx . " received expected response"); } } } # backends send responses foreach my $idx (keys @mbe) { if (exists $be_send->{$idx}) { my $be = $mbe[$idx]; foreach my $send (@{$be_send->{$idx}}) { print $be $send; } } } # verify proxy received response if (scalar @{$ps_recv}) { foreach my $recv (@{$ps_recv}) { is(scalar <$ps>, $recv, "ps returned expected response."); } } else { # makes sure nothing was received when ps_recv is empty. check_version($ps) } } { # Write a request with bad syntax, and check the response. print $ps "set with the wrong number of tokens\n"; is(scalar <$ps>, "CLIENT_ERROR parsing request\r\n", "got CLIENT_ERROR for bad syntax"); } # Basic test with a backend; write a request to the client socket, read it # from a backend socket, and write a response to the backend socket. # # The array @mbe holds references to our sockets for the backends listening on # the above mocked servers. In most tests we're only routing to the first # backend in the list ($mbe[0]) # # In this case the client will receive an error and the backend gets closed, # so we have to re-establish it. { note("Test missing END:" . __LINE__); # Test a fix for passing through partial read data if END ends up missing. my $be = $mbe[0]; my $w = $p_srv->new_sock; print $w "watch proxyevents\n"; is(<$w>, "OK\r\n", "watcher enabled"); # write a request to proxy. print $ps "get /b/a\r\n"; # verify request is received by backend. is(scalar <$be>, "get /b/a\r\n", "get passthrough"); # write a response with partial data. print $be "VALUE /b/a 0 2\r\nhi\r\nEN"; # verify the error response from proxy is(scalar <$ps>, "SERVER_ERROR backend failure\r\n", "backend failure error"); # verify a particular proxy event logline is received like(<$w>, qr/ts=(\S+) gid=\d+ type=proxy_backend error=timeout name=127.0.0.1 port=\d+ depth=1 rbuf=EN/, "got backend error log line"); # backend is disconnected due to the error, so we have to re-establish it. $mbe[0] = accept_backend($mocksrvs[0]); } # This test is similar to the above one, except we also establish a watcher to # check for appropriate log entries. { note("Test trailingdata:" . __LINE__); # Test a log line with detailed data from backend failures. my $be = $mbe[0]; my $w = $p_srv->new_sock; print $w "watch proxyevents\n"; is(<$w>, "OK\r\n", "watcher enabled"); print $ps "get /b/c\r\n"; is(scalar <$be>, "get /b/c\r\n", "get passthrough"); # Set off a "trailing data" error print $be "VALUE /b/c 0 2\r\nok\r\nEND\r\ngarbage"; is(scalar <$ps>, "VALUE /b/c 0 2\r\n", "got value back"); is(scalar <$ps>, "ok\r\n", "got data back"); is(scalar <$ps>, "END\r\n", "got end string"); like(<$w>, qr/ts=(\S+) gid=\d+ type=proxy_backend error=trailingdata name=127.0.0.1 port=\d+ depth=0 rbuf=garbage/, "got backend error log line"); $mbe[0] = accept_backend($mocksrvs[0]); } note("Test bugfix for missingend:" . __LINE__); # This is an example of a test which will only pass before a bugfix is issued. # It's good practice where possible to write a failing test, then check it # against a code fix. We then leave the test in the file for reference. # Though noting when it was fixed is probably better than what I did here :) SKIP: { skip "Remove this skip line to demonstrate pre-patch bug", 1; # Test issue with finding response complete when read lands between value # size and value + response line in size. my $be = $mbe[0]; my $w = $p_srv->new_sock; print $w "watch proxyevents\n"; is(<$w>, "OK\r\n", "watcher enabled"); print $ps "get /b/c\r\n"; is(scalar <$be>, "get /b/c\r\n", "get passthrough"); # Set off a "missingend" error. # The server will wake up several times, thinking it has read the # full size of response but it only read enough for the value portion. print $be "VALUE /b/c 0 5\r\nhe"; sleep 0.1; print $be "llo"; sleep 0.1; print $be "\r\nEND\r\n"; is(scalar <$ps>, "SERVER_ERROR backend failure\r\n"); like(<$w>, qr/ts=(\S+) gid=\d+ type=proxy_backend error=missingend name=127.0.0.1 port=\d+ depth=1 rbuf=/, "got missingend error log line"); $mbe[0] = accept_backend($mocksrvs[0]); } { # Test issue with finding response complete when read lands between value # size and value + response line in size. my $be = $mbe[0]; print $ps "get /b/c\r\n"; is(scalar <$be>, "get /b/c\r\n", "get passthrough"); # Set off a "missingend" error. # The server will wake up several times, thinking it has read the # full size of response but it only read enough for the value portion. print $be "VALUE /b/c 0 5\r\nhe"; sleep 0.1; print $be "llo"; sleep 0.1; print $be "\r\nEND\r\n"; is(scalar <$ps>, "VALUE /b/c 0 5\r\n", "got value back"); is(scalar <$ps>, "hello\r\n", "got data back"); is(scalar <$ps>, "END\r\n", "got end string"); } #diag "ready for main tests"; # Target a single backend, validating basic syntax. # Should test all command types. # uses /b/ path for "basic" { note("Test all commands to a single backend:" . __LINE__); # Test invalid route. print $ps "set /invalid/a 0 0 2\r\nhi\r\n"; is(scalar <$ps>, "SERVER_ERROR no set route\r\n"); # Testing against just one backend. Results should make sense despite our # invalid request above. my $be = $mbe[0]; my $cmd; # TODO: add more tests for the varying response codes. # Basic set. $cmd = "set /b/a 0 0 2"; print $ps "$cmd\r\nhi\r\n"; is(scalar <$be>, "$cmd\r\n", "set passthrough"); is(scalar <$be>, "hi\r\n", "set value"); print $be "STORED\r\n"; is(scalar <$ps>, "STORED\r\n", "got STORED from set"); # Basic get $cmd = "get /b/a\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "get passthrough"); print $be "VALUE /b/a 0 2\r\nhi\r\nEND\r\n"; is(scalar <$ps>, "VALUE /b/a 0 2\r\n", "get rline"); is(scalar <$ps>, "hi\r\n", "get data"); is(scalar <$ps>, "END\r\n", "get end"); # touch $cmd = "touch /b/a 50\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "touch passthrough"); print $be "TOUCHED\r\n"; is(scalar <$ps>, "TOUCHED\r\n", "got touch response"); # gets $cmd = "gets /b/a\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "gets passthrough"); print $be "VALUE /b/a 0 2 2\r\nhi\r\nEND\r\n"; is(scalar <$ps>, "VALUE /b/a 0 2 2\r\n", "gets rline"); is(scalar <$ps>, "hi\r\n", "gets data"); is(scalar <$ps>, "END\r\n", "gets end"); # gat $cmd = "gat 10 /b/a\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "gat passthrough"); print $be "VALUE /b/a 0 2\r\nhi\r\nEND\r\n"; is(scalar <$ps>, "VALUE /b/a 0 2\r\n", "gat rline"); is(scalar <$ps>, "hi\r\n", "gat data"); is(scalar <$ps>, "END\r\n", "gat end"); # gats $cmd = "gats 11 /b/a\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "gats passthrough"); print $be "VALUE /b/a 0 2 1\r\nhi\r\nEND\r\n"; is(scalar <$ps>, "VALUE /b/a 0 2 1\r\n", "gats rline"); is(scalar <$ps>, "hi\r\n", "gats data"); is(scalar <$ps>, "END\r\n", "gats end"); # cas $cmd = "cas /b/a 0 0 2 5"; print $ps "$cmd\r\nhi\r\n"; is(scalar <$be>, "$cmd\r\n", "cas passthrough"); is(scalar <$be>, "hi\r\n", "cas value"); print $be "STORED\r\n"; is(scalar <$ps>, "STORED\r\n", "got STORED from cas"); # add $cmd = "add /b/a 0 0 2"; print $ps "$cmd\r\nhi\r\n"; is(scalar <$be>, "$cmd\r\n", "add passthrough"); is(scalar <$be>, "hi\r\n", "add value"); print $be "STORED\r\n"; is(scalar <$ps>, "STORED\r\n", "got STORED from add"); # delete $cmd = "delete /b/a\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "delete passthrough"); print $be "DELETED\r\n"; is(scalar <$ps>, "DELETED\r\n", "got delete response"); # incr $cmd = "incr /b/a 1\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "incr passthrough"); print $be "2\r\n"; is(scalar <$ps>, "2\r\n", "got incr response"); # decr $cmd = "decr /b/a 1\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "decr passthrough"); print $be "10\r\n"; is(scalar <$ps>, "10\r\n", "got decr response"); # append $cmd = "append /b/a 0 0 2"; print $ps "$cmd\r\nhi\r\n"; is(scalar <$be>, "$cmd\r\n", "append passthrough"); is(scalar <$be>, "hi\r\n", "append value"); print $be "STORED\r\n"; is(scalar <$ps>, "STORED\r\n", "got STORED from append"); # prepend $cmd = "prepend /b/a 0 0 2"; print $ps "$cmd\r\nhi\r\n"; is(scalar <$be>, "$cmd\r\n", "prepend passthrough"); is(scalar <$be>, "hi\r\n", "prepend value"); print $be "STORED\r\n"; is(scalar <$ps>, "STORED\r\n", "got STORED from prepend"); # [meta commands] # testing the bare meta commands. # TODO: add more tests for tokens and changing response codes. # mg $cmd = "mg /b/a\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "mg passthrough"); print $be "HD\r\n"; is(scalar <$ps>, "HD\r\n", "got mg response"); # ms $cmd = "ms /b/a 2"; print $ps "$cmd\r\nhi\r\n"; is(scalar <$be>, "$cmd\r\n", "ms passthrough"); is(scalar <$be>, "hi\r\n", "ms value"); print $be "HD\r\n"; is(scalar <$ps>, "HD\r\n", "got HD from ms"); # md $cmd = "md /b/a\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "md passthrough"); print $be "HD\r\n"; is(scalar <$ps>, "HD\r\n", "got HD from md"); # ma $cmd = "ma /b/a\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "ma passthrough"); print $be "HD\r\n"; is(scalar <$ps>, "HD\r\n", "got HD from ma"); # mn? # me? } # run a cleanser check between each set of tests. # This ensures nothing was left in the client pipeline. check_sanity($ps); { note("Test multiget:" . __LINE__); # multiget syntax # - gets broken into individual gets on backend my $be = $mbe[0]; my $cmd = "get /b/a /b/b /b/c\r\n"; print $ps $cmd; is(scalar <$be>, "get /b/a\r\n", "multiget breakdown a"); is(scalar <$be>, "get /b/b\r\n", "multiget breakdown b"); is(scalar <$be>, "get /b/c\r\n", "multiget breakdown c"); print $be "VALUE /b/a 0 1\r\na\r\n", "END\r\n", "VALUE /b/b 0 1\r\nb\r\n", "END\r\n", "VALUE /b/c 0 1\r\nc\r\n", "END\r\n"; for my $key ('a', 'b', 'c') { is(scalar <$ps>, "VALUE /b/$key 0 1\r\n", "multiget res $key"); is(scalar <$ps>, "$key\r\n", "multiget value $key"); } is(scalar <$ps>, "END\r\n", "final END from multiget"); # Test multiget workaround with misses (known bug) print $ps $cmd; is(scalar <$be>, "get /b/a\r\n", "multiget breakdown a"); is(scalar <$be>, "get /b/b\r\n", "multiget breakdown b"); is(scalar <$be>, "get /b/c\r\n", "multiget breakdown c"); print $be "END\r\nEND\r\nEND\r\n"; is(scalar <$ps>, "END\r\n", "final END from multiget"); # If bugged, the backend will have closed. print $ps "get /b/a\r\n"; is(scalar <$be>, "get /b/a\r\n", "get works after empty multiget"); print $be "END\r\n"; is(scalar <$ps>, "END\r\n", "end after empty multiget"); } check_sanity($ps); { note("Test noreply:" . __LINE__); # noreply tests. # - backend should receive with noreply/q stripped or mangled # - backend should reply as normal # - frontend should get nothing; to test issue another command and ensure # it only gets that response. my $be = $mbe[0]; my $cmd = "set /b/a 0 0 2 noreply\r\nhi\r\n"; print $ps $cmd; is(scalar <$be>, "set /b/a 0 0 2 noreplY\r\n", "set received with broken noreply"); is(scalar <$be>, "hi\r\n", "set payload received"); print $be "STORED\r\n"; # To ensure success, make another req and ensure res isn't STORED $cmd = "touch /b/a 50\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "canary touch received"); print $be "TOUCHED\r\n"; is(scalar <$ps>, "TOUCHED\r\n", "got TOUCHED instread of STORED"); } check_sanity($ps); { subtest 'quiet flag: HD response' => sub { # be_recv must receive a response with quiet flag replaced by a space. # ps_recv must not receoved HD response. proxy_test( ps_send => "ms /b/a 2 q\r\nhi\r\n", be_recv => {0 => ["ms /b/a 2 \r\n", "hi\r\n"]}, be_send => {0 => ["HD\r\n"]}, ); }; subtest 'quiet flag: EX response' => sub { # be_recv must receive a response with quiet flag replaced by a space. # ps_recv must return EX response from the backend. proxy_test( ps_send => "ms /b/a 2 q\r\nhi\r\n", be_recv => {0 => ["ms /b/a 2 \r\n", "hi\r\n"]}, be_send => {0 => ["EX\r\n"]}, ps_recv => ["EX\r\n"], ); }; subtest 'quiet flag: backend failure' => sub { # be_recv must receive a response with quiet flag replaced by a space. # ps_recv must return backend failure response from the backend. proxy_test( ps_send => "ms /b/a 2 q\r\nhi\r\n", be_recv => {0 => ["ms /b/a 2 \r\n", "hi\r\n"]}, be_send => {0 => ["garbage\r\n"]}, ps_recv => ["SERVER_ERROR backend failure\r\n"], ); $mbe[0] = accept_backend($mocksrvs[0]); }; } check_sanity($ps); # Test Lua request API { note("Test Lua request APIs:" . __LINE__); my $be = $mbe[0]; # fetching the key. print $ps "get /getkey/testkey\r\n"; # look for the key to be slightly different to ensure we hit lua. is(scalar <$ps>, "VALUE |/getkey/testkey 0 2\r\n", "request:key()"); is(scalar <$ps>, "ts\r\n", "request:key() value"); is(scalar <$ps>, "END\r\n", "request:key() END"); # rtrimkey # this overwrites part of the key with spaces, which should be skipped by # a valid protocol parser. print $ps "get /rtrimkey/onehalf\r\n"; is(scalar <$be>, "get /rtrimkey/one \r\n", "request:rtrimkey()"); print $be "END\r\n"; is(scalar <$ps>, "END\r\n", "rtrimkey END"); # ltrimkey print $ps "get /ltrimkey/test\r\n"; is(scalar <$be>, "get test\r\n", "request:ltrimkey()"); print $be "END\r\n"; is(scalar <$ps>, "END\r\n", "ltrimkey END"); subtest 'request:ntokens()' => sub { # ps_recv must return value that matches the number of tokens. proxy_test( ps_send => "mg /ntokens/test c v\r\n", ps_recv => ["VA 1 C123 v\r\n", "4\r\n"], ); }; subtest 'request:token() replacement' => sub { # be_recv must received a response with replaced CAS token. proxy_test( ps_send => "ms /token/replacement 2 C123\r\nhi\r\n", be_recv => {0 => ["ms /token/replacement 2 C456\r\n", "hi\r\n"]}, be_send => {0 => ["NF\r\n"]}, ps_recv => ["NF\r\n"], ); }; subtest 'request:token() remove' => sub { # be_recv must received a response with CAS token removed. proxy_test( ps_send => "ms /token/removal 2 C123\r\nhi\r\n", be_recv => {0 => ["ms /token/removal 2 \r\n", "hi\r\n"]}, be_send => {0 => ["NF\r\n"]}, ps_recv => ["NF\r\n"], ); }; subtest 'request:token() fetch' => sub { # be_recv must received the key token in the P flag. proxy_test( ps_send => "ms /token/fetch 2 C123 P\r\nhi\r\n", be_recv => {0 => ["ms /token/fetch 2 C123 P/token/fetch\r\n", "hi\r\n"]}, be_send => {0 => ["HD\r\n"]}, ps_recv => ["HD\r\n"], ); }; # # command() integer subtest 'request:has_flag() meta positive 1' => sub { # ps_recv must receive HD C123 for a successful hash_flag call. proxy_test( ps_send => "mg /hasflag/test c\r\n", ps_recv => ["HD C123\r\n"], ); }; subtest 'request:has_flag() meta positive 2' => sub { # ps_recv must receive HD Oabc for a successful hash_flag call. proxy_test( ps_send => "mg /hasflag/test Oabc T999\r\n", ps_recv => ["HD Oabc\r\n"], ); }; subtest 'request:has_flag() meta negative' => sub { # ps_recv must receive NF when has_flag returns false. proxy_test( ps_send => "mg /hasflag/test T999\r\n", ps_recv => ["NF\r\n"], ); }; subtest 'request:has_flag() none-meta ' => sub { # ps_recv must receive END for a successful hash_flag call. proxy_test( ps_send => "get /hasflag/test\r\n", ps_recv => ["END\r\n"], ); }; subtest 'request:flag_token()' => sub { # be_recv must receive expected flags after a series of flag_token() calls. proxy_test( ps_send => "mg /flagtoken/a N10 k c R10\r\n", ps_recv => ["HD\r\n"], ); }; subtest 'request edit' => sub { # be_recv must receive the edited request. proxy_test( ps_send => "ms /request/edit 2\r\nhi\r\n", be_recv => {0 => ["ms /request/edit 2\r\n", "ab\r\n"]}, be_send => {0 => ["HD\r\n"]}, ps_recv => ["HD\r\n"], ); }; subtest 'request new' => sub { # be_recv must receive the new request. proxy_test( ps_send => "mg /request/old\r\n", be_recv => {0 => ["mg /request/new c\r\n"]}, be_send => {0 => ["HD C123\r\n"]}, ps_recv => ["HD C123\r\n"], ); }; subtest 'request clone response' => sub { # be must receive cloned meta-set from the previous meta-get. my $be = $mbe[0]; print $ps "mg /request/clone v\r\n"; is(scalar <$be>, "mg /request/clone v\r\n", "get passthrough"); print $be "VA 1 v\r\n4\r\n"; is(scalar <$be>, "ms /request/a 1\r\n", "received cloned meta-set"); is(scalar <$be>, "4\r\n", "received cloned meta-set value"); print $be "HD\r\n"; is(scalar <$ps>, "HD\r\n", "received HD"); }; } check_sanity($ps); # Test Lua response API #{ # elapsed() # ok() # hit() # vlen() # code() # line() #} # Test requests land in proper backend in basic scenarios { note("Test routing by zone:" . __LINE__); # TODO: maybe should send values to ensure the right response? # I don't think this test is very useful though; probably better to try # harder when testing error conditions. for my $tu (['a', $mbe[0]], ['b', $mbe[1]], ['c', $mbe[2]]) { my $be = $tu->[1]; my $cmd = "get /zonetest/" . $tu->[0] . "\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "routed proper zone: " . $tu->[0]); print $be "END\r\n"; is(scalar <$ps>, "END\r\n", "end from zone fetch"); } my $cmd = "get /zonetest/invalid\r\n"; print $ps $cmd; is(scalar <$ps>, "END\r\n", "END from invalid route"); } check_sanity($ps); # Test re-requests in lua. # - fetch zones.z1() then fetch zones.z2() # - return z1 or z2 or netiher # - fetch all three zones # - hit the same zone multiple times # Test delayed read (timeout) # Test Lua logging (see t/watcher.t) { note("Test Lua logging:" . __LINE__); my $be = $mbe[0]; my $watcher = $p_srv->new_sock; print $watcher "watch proxyuser proxyreqs\n"; is(<$watcher>, "OK\r\n", "watcher enabled"); # log(msg) print $ps "get /logtest/a\r\n"; like(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_user msg=testing manual log messages/, "log a manual message"); is(scalar <$ps>, "END\r\n", "logtest END"); # log_req(r, res) my $cmd = "get /logreqtest/a\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "got passthru for log"); print $be "END\r\n"; is(scalar <$ps>, "END\r\n", "got END from log test"); like(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_req elapsed=\d+ type=105 code=17 status=0 be=127.0.0.1:11411 detail=logreqtest req=get \/logreqtest\/a/, "found request log entry"); # test log_req with nil res (should be 0's in places) # log_reqsample() } # Basic proxy stats validation # Test user stats check_sanity($ps); # Test await arguments (may move to own file?) # TODO: the results table from mcp.await() contains all of the results so far, # regardless of the mode. # need some tests that show this. { note("Test await argument:" . __LINE__); subtest 'Await hits all 3 backends' => sub { # be_recv must receive hit from all three backends my $key = "/awaitbasic/a"; my $ps_send = "get $key\r\n"; my @be_send = ["VALUE $key 0 2\r\nok\r\nEND\r\n"]; proxy_test( ps_send => $ps_send, be_recv => {0 => [$ps_send], 1 => [$ps_send], 2 => [$ps_send]}, be_send => {0 => @be_send, 1 => @be_send, 2 => @be_send}, ps_recv => ["VALUE $key 0 11\r\n", "hit hit hit\r\n", "END\r\n"], ); }; my $cmd; my $key; # await(r, p, 1) $key = "/awaitone/a"; $cmd = "get $key\r\n"; print $ps $cmd; for my $be (@mbe) { is(scalar <$be>, $cmd, "awaitone backend req"); print $be "VALUE $key 0 2\r\nok\r\nEND\r\n"; } is(scalar <$ps>, "VALUE $key 0 1\r\n", "response from await"); is(scalar <$ps>, "1\r\n", "looking for a single response"); is(scalar <$ps>, "END\r\n", "end from await"); # await(r, p(3+), 2) $key = "/awaitone/b"; $cmd = "get $key\r\n"; print $ps $cmd; for my $be (@mbe) { is(scalar <$be>, $cmd, "awaitone backend req"); print $be "VALUE $key 0 2\r\nok\r\nEND\r\n"; } is(scalar <$ps>, "VALUE $key 0 1\r\n", "response from await"); is(scalar <$ps>, "2\r\n", "looking two responses"); is(scalar <$ps>, "END\r\n", "end from await"); # await(r, p, 1, mcp.AWAIT_GOOD) $key = "/awaitgood/a"; $cmd = "get $key\r\n"; print $ps $cmd; for my $be (@mbe) { is(scalar <$be>, $cmd, "awaitgood backend req"); print $be "VALUE $key 0 2\r\nok\r\nEND\r\n"; } is(scalar <$ps>, "VALUE $key 0 1\r\n", "response from await"); is(scalar <$ps>, "1\r\n", "looking for a single response"); is(scalar <$ps>, "END\r\n", "end from await"); # should test above with first response being err, second good, third # miss, and a few similar iterations. # await(r, p, 2, mcp.AWAIT_ANY) $key = "/awaitany/a"; $cmd = "get $key\r\n"; print $ps $cmd; for my $be (@mbe) { is(scalar <$be>, $cmd, "awaitany backend req"); print $be "VALUE $key 0 2\r\nok\r\nEND\r\n"; } is(scalar <$ps>, "VALUE $key 0 1\r\n", "response from await"); is(scalar <$ps>, "2\r\n", "looking for a two responses"); is(scalar <$ps>, "END\r\n", "end from await"); # await(r, p, 2, mcp.AWAIT_OK) # await(r, p, 1, mcp.AWAIT_FIRST) # more AWAIT_FIRST tests? to see how much it waits on/etc. # await(r, p, 2, mcp.AWAIT_FASTGOOD) # - should return 1 res on good, else wait for N non-error responses $key = "/awaitfastgood/a"; $cmd = "get $key\r\n"; print $ps $cmd; my $fbe = $mbe[0]; is(scalar <$fbe>, $cmd, "awaitfastgood backend req"); print $fbe "VALUE $key 0 2\r\nok\r\nEND\r\n"; # Should have response after the first hit. is(scalar <$ps>, "VALUE $key 0 2\r\n", "response from await"); is(scalar <$ps>, "ok\r\n", "await value"); is(scalar <$ps>, "END\r\n", "end from await"); for my $be ($mbe[1], $mbe[2]) { is(scalar <$be>, $cmd, "awaitfastgood backend req"); print $be "VALUE $key 0 2\r\nok\r\nEND\r\n"; } # test three pools, second response returns good. should have a hit. print $ps $cmd; for my $be (@mbe) { is(scalar <$be>, $cmd, "awaitfastgood backend req"); } $fbe = $mbe[0]; print $fbe "END\r\n"; $fbe = $mbe[1]; print $fbe "VALUE $key 0 2\r\nun\r\nEND\r\n"; is(scalar <$ps>, "VALUE $key 0 2\r\n", "response from await"); is(scalar <$ps>, "un\r\n", "await value"); is(scalar <$ps>, "END\r\n", "end from await"); $fbe = $mbe[2]; print $fbe "END\r\n"; # test three pools, but third returns good. should have returned already print $ps $cmd; for my $be ($mbe[0], $mbe[1]) { is(scalar <$be>, $cmd, "awaitfastgood backend req"); print $be "END\r\n"; } $fbe = $mbe[2]; is(scalar <$fbe>, $cmd, "awaitfastgood backend req"); print $fbe "VALUE $key 0 2\r\nnu\r\nEND\r\n"; is(scalar <$ps>, "END\r\n", "miss from awaitfastgood"); # Testing a set related to fastgood. waiting for two responses. $cmd = "set $key 0 0 2\r\nmo\r\n"; print $ps $cmd; for my $be ($mbe[0], $mbe[1]) { is(scalar <$be>, "set $key 0 0 2\r\n", "set backend req"); is(scalar <$be>, "mo\r\n", "set backend data"); print $be "STORED\r\n"; } is(scalar <$ps>, "STORED\r\n", "got stored from await"); $fbe = $mbe[2]; is(scalar <$fbe>, "set $key 0 0 2\r\n", "set backend req"); is(scalar <$fbe>, "mo\r\n", "set backend data"); print $fbe "STORED\r\n"; # Testing another set; ensure it isn't returning early. my $s = IO::Select->new(); $s->add($ps); print $ps $cmd; for my $be (@mbe) { is(scalar <$be>, "set $key 0 0 2\r\n", "set backend req"); is(scalar <$be>, "mo\r\n", "set backend data"); } $fbe = $mbe[0]; print $fbe "STORED\r\n"; my @readable = $s->can_read(0.25); is(scalar @readable, 0, "set doesn't return early"); for my $be ($mbe[1], $mbe[2]) { print $be "STORED\r\n"; } is(scalar <$ps>, "STORED\r\n", "set completed normally"); # await(r, p, 1, mcp.AWAIT_BACKGROUND) - ensure res without waiting $key = "/awaitbg/a"; $cmd = "get $key\r\n"; print $ps $cmd; # check we can get a response _before_ the backends are consulted. is(scalar <$ps>, "VALUE $key 0 1\r\n", "response from await"); is(scalar <$ps>, "0\r\n", "looking for zero responses"); is(scalar <$ps>, "END\r\n", "end from await"); for my $be (@mbe) { is(scalar <$be>, $cmd, "awaitbg backend req"); print $be "VALUE $key 0 2\r\nok\r\nEND\r\n"; } # test hitting a pool normally then hit mcp.await() # test hitting mcp.await() then a pool normally } check_sanity($ps); { note("Test await_logerrors:" . __LINE__); my $watcher = $p_srv->new_sock; print $watcher "watch proxyreqs\n"; is(<$watcher>, "OK\r\n", "watcher enabled"); # test logging errors from special await. my $key = "/awaitlogerr/a"; my $cmd = "set $key 0 0 5\r\n"; print $ps $cmd . "hello\r\n"; # respond from the first backend normally, then other two with errors. my $be = $mbe[0]; is(scalar <$be>, $cmd, "await_logerrors backend req"); is(scalar <$be>, "hello\r\n", "await_logerrors set payload"); print $be "STORED\r\n"; is(scalar <$ps>, "STORED\r\n", "block until await responded"); # now ship some errors. for my $be ($mbe[1], $mbe[2]) { is(scalar <$be>, $cmd, "await_logerrors backend req"); is(scalar <$be>, "hello\r\n", "await_logerrors set payload"); print $be "SERVER_ERROR out of memory\r\n"; } like(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_req elapsed=\d+ type=\d+ code=\d+ status=-1 be=(\S+) detail=write_failed req=set \/awaitlogerr\/a/, "await_logerrors log entry 1"); like(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_req elapsed=\d+ type=\d+ code=\d+ status=-1 be=(\S+) detail=write_failed req=set \/awaitlogerr\/a/, "await_logerrors log entry 2"); # Repeat the logreqtest to ensure we only got the log lines we expected. $cmd = "get /logreqtest/a\r\n"; print $ps $cmd; is(scalar <$be>, $cmd, "got passthru for log"); print $be "END\r\n"; is(scalar <$ps>, "END\r\n", "got END from log test"); like(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_req elapsed=\d+ type=105 code=17 status=0 be=127.0.0.1:11411 detail=logreqtest req=get \/logreqtest\/a/, "found request log entry"); } check_sanity($ps); # Test out of spec commands from client # - wrong # of tokens # - bad key size # - etc # Test errors/garbage from server # - certain errors pass through to the client, most close the backend. # - should be able to retrieve the error message { note("Test error/garbage from backend:" . __LINE__); my $be = $mbe[0]; print $ps "set /b/foo 0 0 2\r\nhi\r\n"; is(scalar <$be>, "set /b/foo 0 0 2\r\n", "received set cmd"); is(scalar <$be>, "hi\r\n", "received set data"); # Send a classic back up the pipe. my $msg = "SERVER_ERROR object too large for cache\r\n"; print $be $msg; is(scalar <$ps>, $msg, "client received error message"); print $ps "get /b/foo\r\n"; is(scalar <$be>, "get /b/foo\r\n", "backend still works"); print $be "END\r\n"; is(scalar <$ps>, "END\r\n", "got end back"); # ERROR and CLIENT_ERROR should both break the backend. print $ps "get /b/moo\r\n"; is(scalar <$be>, "get /b/moo\r\n", "received get command"); $msg = "CLIENT_ERROR bad command line format\r\n"; my $data; print $be $msg; is(scalar <$ps>, $msg, "client received error message"); my $read = $be->read($data, 1); is($read, 0, "backend disconnected"); $be = $mbe[0] = accept_backend($mocksrvs[0]); print $ps "get /b/too\r\n"; is(scalar <$be>, "get /b/too\r\n", "received get command"); $msg = "ERROR unhappy\r\n"; print $be $msg; is(scalar <$ps>, $msg, "client received error message"); $read = $be->read($data, 1); is($read, 0, "backend disconnected"); $be = $mbe[0] = accept_backend($mocksrvs[0]); # Sometimes blank ERRORS can be sent. print $ps "get /b/zoo\r\n"; is(scalar <$be>, "get /b/zoo\r\n", "received get command"); $msg = "ERROR\r\n"; print $be $msg; is(scalar <$ps>, $msg, "client received error message"); $read = $be->read($data, 1); is($read, 0, "backend disconnected"); $be = $mbe[0] = accept_backend($mocksrvs[0]); # Ensure garbage doesn't surface to client. print $ps "get /b/doo\r\n"; is(scalar <$be>, "get /b/doo\r\n", "received get command"); print $be "garbage\r\n"; # don't need the \r\n but it makes tests easier is(scalar <$ps>, "SERVER_ERROR backend failure\r\n", "generic backend error"); $be = $mbe[0] = accept_backend($mocksrvs[0]); # Check errors from pipelined commands past a CLIENT_ERROR print $ps "get /b/quu\r\nget /b/muu\r\n"; is(scalar <$be>, "get /b/quu\r\n", "received get command"); is(scalar <$be>, "get /b/muu\r\n", "received next get command"); print $be "CLIENT_ERROR bad protocol\r\nEND\r\n"; is(scalar <$ps>, "CLIENT_ERROR bad protocol\r\n", "backend error"); is(scalar <$ps>, "SERVER_ERROR backend failure\r\n", "backend error"); $be = $mbe[0] = accept_backend($mocksrvs[0]); # Check that lua handles errors properly. print $ps "get /errcheck/a\r\n"; is(scalar <$be>, "get /errcheck/a\r\n", "received get command"); print $be "ERROR test1\r\n"; is(scalar <$ps>, "ERROR\r\n", "lua saw correct error code"); $be = $mbe[0] = accept_backend($mocksrvs[0]); print $ps "get /errcheck/b\r\n"; is(scalar <$be>, "get /errcheck/b\r\n", "received get command"); print $be "CLIENT_ERROR test2\r\n"; is(scalar <$ps>, "CLIENT_ERROR\r\n", "lua saw correct error code"); $be = $mbe[0] = accept_backend($mocksrvs[0]); print $ps "get /errcheck/c\r\n"; is(scalar <$be>, "get /errcheck/c\r\n", "received get command"); print $be "SERVER_ERROR test3\r\n"; is(scalar <$ps>, "SERVER_ERROR\r\n", "lua saw correct error code"); } check_sanity($ps); done_testing(); memcached-1.6.20/t/ssl_cert_refresh.t0000664000175000017500000000606614340006077014426 00000000000000#!/usr/bin/env perl use strict; use warnings; use File::Copy; use File::Temp; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; if (!enabled_tls_testing()) { plan skip_all => 'SSL testing is not enabled'; exit 0; } my $ca_cert = File::Temp->new()->filename; my $cert = File::Temp->new()->filename; my $key = File::Temp->new()->filename; my $new_cert_key = File::Temp->new()->filename; my $ca_cert_back = $ca_cert . ".bak"; my $cert_back = $cert . ".bak"; my $key_back = $key . ".bak"; copy("t/" . MemcachedTest::CA_CRT, $ca_cert); copy("t/" . MemcachedTest::SRV_CRT, $cert); copy("t/" . MemcachedTest::SRV_KEY, $key); copy("t/server.pem", $new_cert_key); my $default_crt_ou = "OU=Subunit of Test Organization"; my $server = new_memcached("-o ssl_ca_cert=$ca_cert -o ssl_chain_cert=$cert -o ssl_key=$key"); my $stats = mem_stats($server->sock); my $sock = $server->sock; # This connection should return the default server certificate # memcached was started with. my $cert_details =$sock->dump_peer_certificate(); $cert_details =~ m/(OU=([^\/\n]*))/; is($1, $default_crt_ou, 'Got the default cert'); # Swap a new certificate with a key copy($ca_cert, $ca_cert_back) or die "CA cert backup failed: $!"; copy($cert, $cert_back) or die "Cert backup failed: $!"; copy($key, $key_back) or die "Key backup failed: $!"; copy($new_cert_key, $ca_cert) or die "New CA cert copy failed: $!"; copy($new_cert_key, $cert) or die "New Cert copy failed: $!"; copy($new_cert_key, $key) or die "New key copy failed: $!"; # Ask server to refresh certificates print $sock "refresh_certs\r\n"; is(scalar <$sock>, "OK\r\n", "refreshed certificates"); # New connections should use the new certificate $cert_details = $server->new_sock->dump_peer_certificate(); $cert_details =~ m/(OU=([^\/]*))/; is($1, 'OU=FOR TESTING PURPOSES ONLY','Got the new cert'); # Old connection should use the previous certificate $cert_details = $sock->dump_peer_certificate(); $cert_details =~ m/(OU=([^\/\n]*))/; is($1, $default_crt_ou, 'Old connection still has the old cert'); # Just sleep a while to test the time_since_server_cert_refresh as it's counted # in seconds. sleep 5; $stats = mem_stats($sock); # Restore and ensure previous certificate is back for new connections. move($ca_cert_back, $ca_cert) or die "CA cert restore failed: $!"; move($cert_back, $cert) or die "Cert restore failed: $!"; move($key_back, $key) or die "Key restore failed: $!"; print $sock "refresh_certs\r\n"; is(scalar <$sock>, "OK\r\n", "refreshed certificates"); $cert_details = $server->new_sock->dump_peer_certificate(); $cert_details =~ m/(OU=([^\/\n]*))/; is($1, $default_crt_ou, 'Got the old cert back'); my $stats_after = mem_stats($sock); # We should see last refresh time is reset; hence the new # time_since_server_cert_refresh should be less. cmp_ok($stats_after->{time_since_server_cert_refresh}, '<', $stats->{time_since_server_cert_refresh}, 'Certs refreshed'); done_testing(); END { unlink $ca_cert if $ca_cert; unlink $cert if $cert; unlink $key if $key; unlink $new_cert_key if $new_cert_key; } memcached-1.6.20/t/proxyinternal.lua0000664000175000017500000000654314403667314014335 00000000000000function mcp_config_pools(oldss) mcp.backend_read_timeout(0.5) mcp.backend_connect_timeout(5) local srv = mcp.backend -- Single backend for zones to ease testing. -- For purposes of this config the proxy is always "zone 1" (z1) local b1 = srv('b1', '127.0.0.1', 11611) local b2 = srv('b2', '127.0.0.1', 11612) local b3 = srv('b3', '127.0.0.1', 11613) local b1z = {b1} local b2z = {b2} local b3z = {b3} -- convert the backends to pools. -- as per a normal full config see simple.lua or t/startfile.lua local zones = { z1 = mcp.pool(b1z), z2 = mcp.pool(b2z), z3 = mcp.pool(b3z), } return zones end -- WORKER CODE: -- Using a very simple route handler only to allow testing the three -- workarounds in the same configuration file. function prefix_factory(pattern, list, default) local p = pattern local l = list local d = default return function(r) local route = l[string.match(r:key(), p)] if route == nil then return d(r) end return route(r) end end -- just for golfing the code in mcp_config_routes() function toproute_factory(pfx, label) local err = "SERVER_ERROR no " .. label .. " route\r\n" return prefix_factory("^/(%a+)/", pfx, function(r) return err end) end -- Do specialized testing based on the key prefix. function mcp_config_routes(zones) local pfx_get = {} local pfx_set = {} local pfx_touch = {} local pfx_gets = {} local pfx_gat = {} local pfx_gats = {} local pfx_cas = {} local pfx_add = {} local pfx_delete = {} local pfx_incr = {} local pfx_decr = {} local pfx_append = {} local pfx_prepend = {} local pfx_mg = {} local pfx_ms = {} local pfx_md = {} local pfx_ma = {} local basic = function(r) return mcp.internal(r) end pfx_get["b"] = basic pfx_set["b"] = basic pfx_touch["b"] = basic pfx_gets["b"] = basic pfx_gat["b"] = basic pfx_gats["b"] = basic pfx_cas["b"] = basic pfx_add["b"] = basic pfx_delete["b"] = basic pfx_incr["b"] = basic pfx_decr["b"] = basic pfx_append["b"] = basic pfx_prepend["b"] = basic pfx_mg["b"] = basic pfx_ms["b"] = basic pfx_md["b"] = basic pfx_ma["b"] = basic mcp.attach(mcp.CMD_GET, toproute_factory(pfx_get, "get")) mcp.attach(mcp.CMD_SET, toproute_factory(pfx_set, "set")) mcp.attach(mcp.CMD_TOUCH, toproute_factory(pfx_touch, "touch")) mcp.attach(mcp.CMD_GETS, toproute_factory(pfx_gets, "gets")) mcp.attach(mcp.CMD_GAT, toproute_factory(pfx_gat, "gat")) mcp.attach(mcp.CMD_GATS, toproute_factory(pfx_gats, "gats")) mcp.attach(mcp.CMD_CAS, toproute_factory(pfx_cas, "cas")) mcp.attach(mcp.CMD_ADD, toproute_factory(pfx_add, "add")) mcp.attach(mcp.CMD_DELETE, toproute_factory(pfx_delete, "delete")) mcp.attach(mcp.CMD_INCR, toproute_factory(pfx_incr, "incr")) mcp.attach(mcp.CMD_DECR, toproute_factory(pfx_decr, "decr")) mcp.attach(mcp.CMD_APPEND, toproute_factory(pfx_append, "append")) mcp.attach(mcp.CMD_PREPEND, toproute_factory(pfx_prepend, "prepend")) mcp.attach(mcp.CMD_MG, toproute_factory(pfx_mg, "mg")) mcp.attach(mcp.CMD_MS, toproute_factory(pfx_ms, "ms")) mcp.attach(mcp.CMD_MD, toproute_factory(pfx_md, "md")) mcp.attach(mcp.CMD_MA, toproute_factory(pfx_ma, "ma")) end memcached-1.6.20/t/issue_67.t0000664000175000017500000000561514340006077012535 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 24; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; use Carp qw(croak); use Socket qw(sockaddr_in INADDR_ANY PF_INET SOCK_STREAM); use Cwd; my $builddir = getcwd; $ENV{'MEMCACHED_PORT_FILENAME'} = "/tmp/ports.$$"; sub read_ports { my %rv = (); open(my $f, "/tmp/ports.$$") || die("Can't open ports file."); while(<$f>) { my ($type, $port) = split(/:\s+/); $rv{$type} = $port + 0; } unlink "/tmp/ports.$$"; return %rv; } sub validate_port { my ($name, $got, $expected) = @_; # diag "Wanted $expected, got $got"; if ($expected == -1) { ok(!defined($got), "$name expected no port, got $got"); } elsif ($expected == 0) { ok(defined($got) && $got != 11211, "$name expected random port (got $got)"); } else { is($got, $expected, "$name"); } } sub skip_if_default_addr_in_use(&) { my ($block) = @_; socket(my $socket, PF_INET, SOCK_STREAM, 0) or die $!; my $addr_in_use = !bind($socket, sockaddr_in(11211, INADDR_ANY)); close($socket); SKIP: { skip 'Default address is in use. Do you have a running instance?', 2 if $addr_in_use; return $block->(); } } sub run_server { my ($args) = @_; my $exe = "$builddir/memcached-debug"; croak("memcached binary doesn't exist. Haven't run 'make' ?\n") unless -e $exe; my $childpid = fork(); my $root = ''; $root = "-u root" if ($< == 0); # test build requires more privileges $args .= " -o relaxed_privileges"; my $cmd = "$builddir/timedrun 10 $exe $root $args"; unless($childpid) { exec $cmd; exit; # NOTREACHED } for (1..20) { if (-f "/tmp/ports.$$") { return Memcached::Handle->new(pid => $childpid); } select undef, undef, undef, 0.10; } croak "Failed to start server."; } sub when { my ($name, $params, $expected_tcp, $expected_udp) = @_; my $server = run_server($params); my %ports = read_ports(); validate_port($name, $ports{'TCP INET'}, $expected_tcp); validate_port($name, $ports{'UDP INET'}, $expected_udp); } skip_if_default_addr_in_use { when('no arguments', '', 11211, -1) }; when('specifying tcp port', '-p 11212', 11212, -1); when('specifying udp port', '-U 11222', 11222, 11222); when('specifying tcp ephemeral port', '-p -1', 0, -1); when('specifying udp ephemeral port', '-U -1', 0, 0); when('tcp port disabled', '-p 0', -1, -1); skip_if_default_addr_in_use { when('udp port disabled', '-U 0', 11211, -1) }; when('specifying tcp and udp ports', '-p 11232 -U 11233', 11232, 11233); when('specifying tcp and disabling udp', '-p 11242 -U 0', 11242, -1); when('specifying udp and disabling tcp', '-p -1 -U 11252', 0, 11252); when('specifying tcp and ephemeral udp', '-p 11262 -U -1', 11262, 0); when('specifying udp and ephemeral tcp', '-p -1 -U 11272', 0, 11272); memcached-1.6.20/t/client_key.pem0000664000175000017500000000321714204760331013530 00000000000000-----BEGIN RSA PRIVATE KEY----- MIIEpAIBAAKCAQEA1WbJye9krQ/H/nT75HWzdmB/u1446SXkcIyZY612JrgGZfUO tm8iZrdLeoxPOvsOrMEObnbbtZWD1KKG63hjxdNHl9luDznuzVG2r80BLKDAu1jr I2qqCeNpMS6DSYhCcX0lqvFjXpOlRBlHsjscevHyJHVRbxN+miQsQuMjMbbd+lA2 ku/DwkD+RbmAedlkYgL03oxY+nS5+mUIj0Z5qMZp34juGNhNkKYwTz23eFYepyQg SDvlq+eOQW6f8T009hqj760/hwC5iA+/zsROSvwekENAsd+GzN0eNU+VnChl5F66 DQs/x18os0q+0tdPONrwPWg8QOfb/Xp5iUxD0QIDAQABAoIBAFbHF6NwH8ZoNnF4 7L14R2QJ1adBp27Xo89IvU9VSEhyaNepETSKeLjALIdG6ykW0l7Zmp684pcyl4su FCNIr3nQcrqDBkhWzI7dfaZ7fNDDBdypSeT7CO5AdZQ0T9rk9+/ibiDXTAs3iuro RMlrVCeCn27H7jd2+/J+ZylD6BncfpgF6wAz80Ac6PzhlE28tjl8JhDV3AQtoSXp 1oFFT1OIvg6+0FcrxocGsM61akEKdJYmWP8mvQvBWIDFKib9VQuIQ3UEJrwG8H6A at1H1hFIZpgYTXJnU1n34xxfml16kSpp61Sap531vwLrfi6jrsCgCppdfpX3HEdl ApGed0kCgYEA9MgV1cB3W/18zALmVf3LRfwVT2oAikeIYr34AcdQ+09TYo20iFIi +s993M5LOIRkXuL1a3zQYzQplp5hwyXy0+4v6NVHDiEothbOcViCE6pxesHxRlty ujud2taUIXo3z+fod0TBW19MOzC2EZFzuy6XOle2uTe785NzmmGtKpsCgYEA3y6I z53b1S4uXtqm494pPxhYvQTZJZND5XeIIW/L/WjWZaLlXtwqv/x94PyX9a3BjLvC NHuAJDV54KOXZDLn5d+nuqYhwx6DQ6eARTRkqcbsMxqBpbOxHo1CInUWkbCAzeI6 JiHa6+mbfyF1j9waxUcLLVCvI7/chYGCwEZojAMCgYAZOe2WI8mpP0x3Me1O+2LR iZMgpgn8NjcGBhHjDQl5fMlZJMVwLxbPxkZwVQpHfs1hQf6M30YSkzOeBCCLHgQS dz+UvTYfbKdnbJ5F7Bsrr6sWPZqB57bBHpe8D9UgRhouYPYCJKHQqteOWgzJbrYA mmKXbqa0G9xQ0+dcB6jy9QKBgQDcuRoHMxkJ8b1chCSPsdTbGMoSTmwvlECO/bN9 ViLJwVhgdkUgluAUtbMMwuPKzwhflgXQf9/Qb67UsxXzu8DLAHHSz6EOZuvtCgh6 6QExQ5GwTOOxrFBcZdnlWCV0+rm4ZKebtNndfVES31V0bHtxZfyw2V4NHiALTXWx kTCuXwKBgQDfDWjNsvHjHtY2RDO6OwI/X9sME49l9MmyaFlr7eCTvuGpTvvaZSvD vJV2J9aBqlJlowpoH0UCy2TWjVSlh3GLFqlKVGOEVIT3FaR2QLHESzNhMCLoYKfd 819yNk6np4WYrN7RpcVoG1XR8sj4NJJQZJy0Iu1N8tnPm9AZEu8jxQ== -----END RSA PRIVATE KEY----- memcached-1.6.20/t/misbehave.t0000775000175000017500000000120314340006077013024 00000000000000#!/usr/bin/env perl use strict; use Test::More; use FindBin qw($Bin); use Socket qw(MSG_PEEK MSG_DONTWAIT); use lib "$Bin/lib"; use MemcachedTest; if (!enabled_tls_testing() && supports_drop_priv()) { plan tests => 1; } else { plan skip_all => 'Privilege drop not supported'; exit 0; } my $server = new_memcached('-o drop_privileges'); my $sock = $server->sock; print $sock "misbehave\r\n"; sleep(1); # check if the socket is dead now my $buff; my $ret = recv($sock, $buff, 1, MSG_PEEK | MSG_DONTWAIT); # ret = 0 means read 0 bytes, which means a closed socket ok($ret == 0, "did not allow misbehaving"); $server->DESTROY(); memcached-1.6.20/t/extstore-buckets.t0000664000175000017500000000340214340006077014374 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; use Data::Dumper qw/Dumper/; my $ext_path; if (!supports_extstore()) { plan skip_all => 'extstore not enabled'; exit 0; } $ext_path = "/tmp/extstore.$$"; my $server = new_memcached("-m 256 -U 0 -o ext_page_size=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0,ext_path=$ext_path:64m,ext_low_ttl=60,slab_automove=1"); my $sock = $server->sock; my $value; { my @chars = ("C".."Z"); for (1 .. 20000) { $value .= $chars[rand @chars]; } } # fill some larger objects { # interleave sets with 0 ttl vs long ttl's. my $keycount = 1200; for (1 .. $keycount) { print $sock "set nfoo$_ 0 0 20000 noreply\r\n$value\r\n"; print $sock "set lfoo$_ 0 5 20000 noreply\r\n$value\r\n"; } # wait for a flush sleep 10; print $sock "lru_crawler crawl all\r\n"; <$sock>; sleep 2; # fetch mem_get_is($sock, "nfoo1", $value); # check extstore counters my $stats = mem_stats($sock); cmp_ok($stats->{extstore_page_allocs}, '>', 0, 'at least one page allocated'); cmp_ok($stats->{extstore_objects_written}, '>', $keycount / 2, 'some objects written'); cmp_ok($stats->{extstore_bytes_written}, '>', length($value) * 2, 'some bytes written'); cmp_ok($stats->{get_extstore}, '>', 0, 'one object was fetched'); cmp_ok($stats->{extstore_objects_read}, '>', 0, 'one object read'); cmp_ok($stats->{extstore_bytes_read}, '>', length($value), 'some bytes read'); cmp_ok($stats->{extstore_page_reclaims}, '>', 1, 'at least two pages reclaimed'); } done_testing(); END { unlink $ext_path if $ext_path; } memcached-1.6.20/t/stress-memcached.pl0000775000175000017500000000427114340006077014470 00000000000000#!/usr/bin/env perl # use strict; use lib '../../api/perl/lib'; use Cache::Memcached; use Time::HiRes qw(time); unless (@ARGV == 2) { die "Usage: stress-memcached.pl ip:port threads\n"; } my $host = shift; my $threads = shift; my $memc = new Cache::Memcached; $memc->set_servers([$host]); unless ($memc->set("foo", "bar") && $memc->get("foo") eq "bar") { die "memcached not running at $host ?\n"; } $memc->disconnect_all(); my $running = 0; while (1) { if ($running < $threads) { my $cpid = fork(); if ($cpid) { $running++; #print "Launched $cpid. Running $running threads.\n"; } else { stress(); exit 0; } } else { wait(); $running--; } } sub stress { undef $memc; $memc = new Cache::Memcached; $memc->set_servers([$host]); my ($t1, $t2); my $start = sub { $t1 = time(); }; my $stop = sub { my $op = shift; $t2 = time(); my $td = sprintf("%0.3f", $t2 - $t1); if ($td > 0.25) { print "Took $td seconds for: $op\n"; } }; my $max = rand(50); my $sets = 0; for (my $i = 0; $i < $max; $i++) { my $key = key($i); my $set = $memc->set($key, $key); $sets++ if $set; } for (1..int(rand(500))) { my $rand = int(rand($max)); my $key = key($rand); my $meth = int(rand(3)); my $exp = int(rand(3)); undef $exp unless $exp; $start->(); if ($meth == 0) { $memc->add($key, $key, $exp); $stop->("add"); } elsif ($meth == 1) { $memc->delete($key); $stop->("delete"); } else { $memc->set($key, $key, $exp); $stop->("set"); } $rand = int(rand($max)); $key = key($rand); $start->(); my $v = $memc->get($key); $stop->("get"); if ($v && $v ne $key) { die "Bogus: $v for key $rand\n"; } } $start->(); my $multi = $memc->get_multi(map { key(int(rand($max))) } (1..$max)); $stop->("get_multi"); } sub key { my $n = shift; $_ = sprintf("%04d", $n); if ($n % 2) { $_ .= "a"x20; } $_; } memcached-1.6.20/t/slabs-reassign2.t0000664000175000017500000000750014340006077014063 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More tests => 12; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; use Data::Dumper qw/Dumper/; my $server = new_memcached('-m 60 -o slab_reassign,slab_automove,lru_crawler,lru_maintainer,slab_automove_window=3'); my $sock = $server->sock; my $value = "B"x11000; my $keycount = 5000; my $res; for (1 .. $keycount) { print $sock "set nfoo$_ 0 0 11000 noreply\r\n$value\r\n"; } my $todelete = 0; { my $stats = mem_stats($sock); cmp_ok($stats->{curr_items}, '>', 4000, "stored at least 4000 11k items"); $todelete = $stats->{curr_items}; # for ('evictions', 'reclaimed', 'curr_items', 'cmd_set', 'bytes') { # print STDERR "$_: ", $stats->{$_}, "\n"; # } } # Make room in old class so rescues can happen when we switch slab classes. for (1 .. $todelete) { next unless $_ % 2 == 0; print $sock "delete nfoo$_ noreply\r\n"; } { my $tries; for ($tries = 20; $tries > 0; $tries--) { sleep 1; my $stats = mem_stats($sock); if ($stats->{slab_global_page_pool} > 24) { last; } } cmp_ok($tries, '>', 0, 'some pages moved back to global pool'); } $value = "B"x7000; for (1 .. $keycount) { print $sock "set ifoo$_ 0 0 7000 noreply\r\n$value\r\n"; } my $missing = 0; my $hits = 0; for (1 .. $keycount) { print $sock "get ifoo$_\r\n"; my $body = scalar(<$sock>); my $expected = "VALUE ifoo$_ 0 7000\r\n$value\r\nEND\r\n"; if ($body =~ /^END/) { $missing++; } else { $body .= scalar(<$sock>) . scalar(<$sock>); if ($body ne $expected) { print STDERR "Something terrible has happened: $expected\nBODY:\n$body\nDONETEST\n"; } else { $hits++; } } } #print STDERR "HITS: $hits, MISSES: $missing\n"; { my $stats = mem_stats($sock); cmp_ok($stats->{evictions}, '<', 2000, 'evictions were less than 2000'); # for ('evictions', 'reclaimed', 'curr_items', 'cmd_set', 'bytes') { # print STDERR "$_: ", $stats->{$_}, "\n"; # } } # Force reassign evictions by moving too much memory manually. { my $s = mem_stats($sock, 'slabs'); my $max_pages = 0; my $scls = 0; for my $k (keys %$s) { next unless $k =~ m/^(\d+)\:total_pages/; if ($s->{$k} > $max_pages) { $max_pages = $s->{$k}; $scls = $1; } } my $tries; for ($tries = 10; $tries > 0; $tries--) { print $sock "slabs reassign $scls 1\r\n"; my $res = <$sock>; sleep 1; my $s = mem_stats($sock); last if $s->{slab_reassign_evictions_nomem} > 0; } cmp_ok($tries, '>', 0, 'some reassign evictions happened'); } cmp_ok($hits, '>', 2000, 'were able to fetch back some of the small keys'); my $stats_done = mem_stats($sock); cmp_ok($stats_done->{slab_reassign_rescues}, '>', 0, 'some reassign rescues happened'); print $sock "flush_all\r\n"; is(scalar <$sock>, "OK\r\n", "did flush_all"); my $tries; for ($tries = 20; $tries > 0; $tries--) { sleep 1; my $stats = mem_stats($sock); if ($stats->{slab_global_page_pool} > 50) { last; } } cmp_ok($tries, '>', 0, 'reclaimed at least 50 pages before timeout'); { my $stats = mem_stats($sock, "slabs"); is($stats->{total_malloced}, 62914560, "total_malloced is what we expect"); } # Set into an entirely new class. Overload a bit to try to cause problems. $value = "B"x4096; for (1 .. $keycount * 4) { print $sock "set jfoo$_ 0 0 4096 noreply\r\n$value\r\n"; } { my $stats = mem_stats($sock); cmp_ok($stats->{curr_items}, '>', 10000, "stored at least 10000 4k items"); is($stats->{slab_global_page_pool}, 0, "drained the global page pool"); } { my $stats = mem_stats($sock, "slabs"); is($stats->{total_malloced}, 62914560, "total_malloced is same after re-assignment"); } memcached-1.6.20/t/ssl_session_resumption.t0000664000175000017500000000373614340006077015724 00000000000000#!/usr/bin/env perl use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; if (!enabled_tls_testing()) { plan skip_all => 'SSL testing is not enabled'; exit 0; } my $server; my $sock; my $stats; my $session_cache = eval qq{ IO::Socket::SSL::Session_Cache->new(1); }; ### Disabled SSL session cache $server = new_memcached(); $stats = mem_stats($server->sock); is($stats->{ssl_new_sessions}, undef, "new SSL sessions not recorded when session cache is disabled"); my $disabled_initial_total_conns = $stats->{total_connections}; $sock = $server->new_sock($session_cache, 'TLSv1_2'); $stats = mem_stats($sock); cmp_ok($stats->{total_connections}, '>', $disabled_initial_total_conns, "client-side session cache is noop in establishing a new connection"); is($sock->get_session_reused(), 0, "client-side session cache is unused"); ### Enabled SSL session cache $server = new_memcached("-o ssl_session_cache"); # Support for session caching in IO::Socket::SSL for TLS v1.3 is incomplete. # Here, we will deliberately force TLS v1.2 to test session caching. $sock = $server->new_sock($session_cache, 'TLSv1_2'); $stats = mem_stats($sock); cmp_ok($stats->{total_connections}, '>', 0, "initial connection is established"); SKIP: { skip "sessions counter accuracy requires OpenSSL 1.1.1 or newer", 1; cmp_ok($stats->{ssl_new_sessions}, '>', 0, "successful new SSL session"); } my $enabled_initial_ssl_sessions = $stats->{ssl_new_sessions}; my $enabled_initial_total_conns = $stats->{total_connections}; # Create a new client with the same session cache $sock = $server->new_sock($session_cache, 'TLSv1_2'); $stats = mem_stats($sock); cmp_ok($stats->{total_connections}, '>', $enabled_initial_total_conns, "new connection is established"); is($stats->{ssl_new_sessions}, $enabled_initial_ssl_sessions, "no new SSL sessions are created on the server"); is($sock->get_session_reused(), 1, "client-persisted session is reused"); done_testing(); memcached-1.6.20/t/expirations.t0000775000175000017500000000736714340006077013447 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 41; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $expire; sub wait_for_early_second { my $have_hires = eval "use Time::HiRes (); 1"; if ($have_hires) { my $tsh = Time::HiRes::time(); my $ts = int($tsh); return if ($tsh - $ts) < 0.5; } my $ts = int(time()); while (1) { my $t = int(time()); return if $t != $ts; select undef, undef, undef, 0.10; # 1/10th of a second sleeps until time changes. } } wait_for_early_second(); # set&add expiration test print $sock "set foo 0 3 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", "fooval"); mem_move_time($sock, 3); mem_get_is($sock, "foo", undef); $expire = time() - 1; print $sock "set foo 0 $expire 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", undef, "already expired"); $expire = time() + 4; print $sock "set foo 0 $expire 6\r\nfoov+1\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", "foov+1"); mem_move_time($sock, 4); mem_get_is($sock, "foo", undef, "now expired"); $expire = time() - 20; print $sock "set boo 0 $expire 6\r\nbooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored boo"); mem_get_is($sock, "boo", undef, "now expired"); $expire = -1; print $sock "set boo 0 $expire 6\r\nbooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored boo"); mem_get_is($sock, "boo", undef, "now expired"); print $sock "add add 0 2 6\r\naddval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored add"); mem_get_is($sock, "add", "addval"); print $sock "add add 0 2 7\r\naddval2\r\n"; is(scalar <$sock>, "NOT_STORED\r\n", "add failure"); mem_move_time($sock, 2); print $sock "add add 0 2 7\r\naddval3\r\n"; is(scalar <$sock>, "STORED\r\n", "stored add again"); mem_get_is($sock, "add", "addval3"); # touch expiration test print $sock "set tch 0 0 8\r\ntouchval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored tch"); $expire = time() - 1; print $sock "touch tch $expire\r\n"; is(scalar <$sock>, "TOUCHED\r\n", "touched tch"); mem_get_is($sock, "touch", undef, "now expired"); print $sock "set tch 0 0 8\r\ntouchval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored tch"); $expire = time() + 1; print $sock "touch tch $expire\r\n"; is(scalar <$sock>, "TOUCHED\r\n", "touched tch"); mem_move_time($sock, 1); mem_get_is($sock, "touch", undef, "now expired"); print $sock "set tch 0 0 8\r\ntouchval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored tch"); $expire = -1; print $sock "touch tch $expire\r\n"; is(scalar <$sock>, "TOUCHED\r\n", "touched tch"); mem_get_is($sock, "touch", undef, "now expired"); # get and touch expiration test print $sock "set gat 0 0 6\r\ngatval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored gat"); $expire = time() - 1; print $sock "gat $expire gat\r\n"; is(scalar <$sock>, "VALUE gat 0 6\r\n","get and touch gat"); is(scalar <$sock>, "gatval\r\n","value"); is(scalar <$sock>, "END\r\n", "end"); mem_get_is($sock, "gat", undef, "now expired"); print $sock "set gat 0 0 6\r\ngatval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored gat"); $expire = time() + 1; print $sock "gat $expire gat\r\n"; is(scalar <$sock>, "VALUE gat 0 6\r\n","get and touch gat"); is(scalar <$sock>, "gatval\r\n","value"); is(scalar <$sock>, "END\r\n", "end"); mem_move_time($sock, 1); mem_get_is($sock, "gat", undef, "now expired"); print $sock "set gat 0 0 6\r\ngatval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored gat"); $expire = -1; print $sock "gat $expire gat\r\n"; is(scalar <$sock>, "VALUE gat 0 6\r\n","get and touch gat"); is(scalar <$sock>, "gatval\r\n","value"); is(scalar <$sock>, "END\r\n", "end"); mem_get_is($sock, "gat", undef, "now expired"); memcached-1.6.20/t/binary-get.t0000775000175000017500000000076714340006077013140 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 8; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $count = 1; foreach my $blob ("mooo\0", "mumble\0\0\0\0\r\rblarg", "\0", "\r") { my $key = "foo$count"; my $len = length($blob); print "len is $len\n"; print $sock "set $key 0 0 $len\r\n$blob\r\n"; is(scalar <$sock>, "STORED\r\n", "stored $key"); mem_get_is($sock, $key, $blob); $count++; } memcached-1.6.20/t/lib/0000755000175000017500000000000014427543277011537 500000000000000memcached-1.6.20/t/lib/MemcachedTest.pm0000664000175000017500000003401114427543277014524 00000000000000package MemcachedTest; use strict; use IO::Socket::INET; use IO::Socket::UNIX; use POSIX ":sys_wait_h"; use Exporter 'import'; use Carp qw(croak); use vars qw(@EXPORT); # Instead of doing the substitution with Autoconf, we assume that # cwd == builddir. use Cwd; my $builddir = getcwd; my @unixsockets = (); @EXPORT = qw(new_memcached sleep mem_get_is mem_gets mem_gets_is mem_stats mem_move_time supports_sasl free_port supports_drop_priv supports_extstore wait_ext_flush supports_tls enabled_tls_testing run_help supports_unix_socket get_memcached_exe supports_proxy); use constant MAX_READ_WRITE_SIZE => 16384; use constant SRV_CRT => "server_crt.pem"; use constant SRV_KEY => "server_key.pem"; use constant CLIENT_CRT => "client_crt.pem"; use constant CLIENT_KEY => "client_key.pem"; use constant CA_CRT => "cacert.pem"; my $testdir = $builddir . "/t/"; my $client_crt = $testdir. CLIENT_CRT; my $client_key = $testdir. CLIENT_KEY; my $server_crt = $testdir . SRV_CRT; my $server_key = $testdir . SRV_KEY; my $tls_checked = 0; sub sleep { my $n = shift; select undef, undef, undef, $n; } # Wait until all items have flushed sub wait_ext_flush { my $sock = shift; my $target = shift || 0; my $sum = $target + 1; while ($sum > $target) { my $s = mem_stats($sock, "items"); $sum = 0; for my $key (keys %$s) { if ($key =~ m/items:(\d+):number/) { # Ignore classes which can contain extstore items next if $1 < 3; $sum += $s->{$key}; } } sleep 1 if $sum > $target; } } sub mem_stats { my ($sock, $type) = @_; $type = $type ? " $type" : ""; print $sock "stats$type\r\n"; my $stats = {}; while (<$sock>) { last if /^(\.|END)/; /^(STAT|ITEM) (\S+)\s+([^\r\n]+)/; #print " slabs: $_"; $stats->{$2} = $3; } return $stats; } sub mem_move_time { my ($sock, $move) = @_; print $sock "debugtime $move\r\n"; <$sock>; } sub mem_get_is { # works on single-line values only. no newlines in value. my ($sock_opts, $key, $val, $msg) = @_; my $opts = ref $sock_opts eq "HASH" ? $sock_opts : {}; my $sock = ref $sock_opts eq "HASH" ? $opts->{sock} : $sock_opts; my $expect_flags = $opts->{flags} || 0; my $dval = defined $val ? "'$val'" : ""; $msg ||= "$key == $dval"; print $sock "get $key\r\n"; if (! defined $val) { my $line = scalar <$sock>; if ($line =~ /^VALUE/) { $line .= scalar(<$sock>) . scalar(<$sock>); } Test::More::is($line, "END\r\n", $msg); } else { my $len = length($val); my $body = scalar(<$sock>); my $expected = "VALUE $key $expect_flags $len\r\n$val\r\nEND\r\n"; if (!$body || $body =~ /^END/) { Test::More::is($body, $expected, $msg); return; } $body .= scalar(<$sock>) . scalar(<$sock>); Test::More::is($body, $expected, $msg); } } sub mem_gets { # works on single-line values only. no newlines in value. my ($sock_opts, $key) = @_; my $opts = ref $sock_opts eq "HASH" ? $sock_opts : {}; my $sock = ref $sock_opts eq "HASH" ? $opts->{sock} : $sock_opts; my $val; my $expect_flags = $opts->{flags} || 0; print $sock "gets $key\r\n"; my $response = <$sock>; if ($response =~ /^END/) { return "NOT_FOUND"; } else { $response =~ /VALUE (.*) (\d+) (\d+) (\d+)/; my $flags = $2; my $len = $3; my $identifier = $4; read $sock, $val , $len; # get the END $_ = <$sock>; $_ = <$sock>; return ($identifier,$val); } } sub mem_gets_is { # works on single-line values only. no newlines in value. my ($sock_opts, $identifier, $key, $val, $msg) = @_; my $opts = ref $sock_opts eq "HASH" ? $sock_opts : {}; my $sock = ref $sock_opts eq "HASH" ? $opts->{sock} : $sock_opts; my $expect_flags = $opts->{flags} || 0; my $dval = defined $val ? "'$val'" : ""; $msg ||= "$key == $dval"; print $sock "gets $key\r\n"; if (! defined $val) { my $line = scalar <$sock>; if ($line =~ /^VALUE/) { $line .= scalar(<$sock>) . scalar(<$sock>); } Test::More::is($line, "END\r\n", $msg); } else { my $len = length($val); my $body = scalar(<$sock>); my $expected = "VALUE $key $expect_flags $len $identifier\r\n$val\r\nEND\r\n"; if (!$body || $body =~ /^END/) { Test::More::is($body, $expected, $msg); return; } $body .= scalar(<$sock>) . scalar(<$sock>); Test::More::is($body, $expected, $msg); } } sub free_port { my $type = shift || "tcp"; my $sock; my $port; while (!$sock) { $port = int(rand(20000)) + 30000; if (enabled_tls_testing()) { $sock = eval qq{ IO::Socket::SSL->new(LocalAddr => '127.0.0.1', LocalPort => $port, Proto => '$type', ReuseAddr => 1, SSL_verify_mode => SSL_VERIFY_NONE); }; die $@ if $@; # sanity check. } else { $sock = IO::Socket::INET->new(LocalAddr => '127.0.0.1', LocalPort => $port, Proto => $type, ReuseAddr => 1); } } return $port; } sub print_help { my $exe = get_memcached_exe(); my $output = `$exe -h`; return $output; } sub supports_udp { my $output = print_help(); return 0 if $output =~ /^memcached 1\.1\./; return 1; } sub supports_sasl { my $output = print_help(); return 1 if $output =~ /sasl/i; return 0; } sub supports_extstore { my $output = print_help(); return 1 if $output =~ /ext_path/i; return 0; } sub supports_proxy { my $output = print_help(); return 1 if $output =~ /proxy_config/i; return 0; } sub supports_tls { my $output = print_help(); return 1 if $output =~ /enable-ssl/i; return 0; } sub supports_unix_socket { my $output = print_help(); return 1 if $output =~ /unix-socket/i; return 0; } sub enabled_tls_testing { if ($tls_checked) { return 1; } elsif (supports_tls() && $ENV{SSL_TEST}) { eval "use IO::Socket::SSL"; croak("IO::Socket::SSL not installed or failed to load, cannot run SSL tests as requested") if $@; $tls_checked = 1; return 1; } } sub supports_drop_priv { my $output = print_help(); return 1 if $output =~ /no_drop_privileges/i; return 0; } sub get_memcached_exe { my $exe = "$builddir/memcached-debug"; croak("memcached binary doesn't exist. Haven't run 'make' ?\n") unless -e $exe; croak("memcached binary not executable\n") unless -x _; return $exe; } sub run_help { my $exe = get_memcached_exe(); return system("$exe -h"); } # -1 if the pid is actually dead. sub is_running { return waitpid($_[0], WNOHANG) >= 0 ? 1 : 0; } sub new_memcached { my ($args, $passed_port) = @_; my $port = $passed_port; my $host = '127.0.0.1'; my $ssl_enabled = enabled_tls_testing(); my $unix_socket_disabled = !supports_unix_socket(); if ($ENV{T_MEMD_USE_DAEMON}) { my ($host, $port) = ($ENV{T_MEMD_USE_DAEMON} =~ m/^([^:]+):(\d+)$/); my $conn; if ($ssl_enabled) { $conn = eval qq{IO::Socket::SSL->new(PeerAddr => "$host:$port", SSL_verify_mode => SSL_VERIFY_NONE, SSL_cert_file => '$client_crt', SSL_key_file => '$client_key'); }; die $@ if $@; # sanity check. } else { $conn = IO::Socket::INET->new(PeerAddr => "$host:$port"); } if ($conn) { return Memcached::Handle->new(conn => $conn, host => $host, port => $port); } croak("Failed to connect to specified memcached server.") unless $conn; } if ($< == 0) { $args .= " -u root"; } $args .= " -o relaxed_privileges"; my $udpport; if ($args =~ /-l (\S+)/ || (($ssl_enabled || $unix_socket_disabled) && ($args !~ /-s (\S+)/))) { if (!$port) { $port = free_port(); } $udpport = free_port("udp"); $args .= " -p $port"; if (supports_udp() && $args !~ /-U (\S+)/) { $args .= " -U $udpport"; } if ($ssl_enabled) { $args .= " -Z"; if ($args !~ /-o ssl_chain_cert=(\S+)/) { $args .= " -o ssl_chain_cert=$server_crt"; } if ($args !~ /-o ssl_key=(\S+)/) { $args .= " -o ssl_key=$server_key"; } } } elsif ($args !~ /-s (\S+)/) { my $num = @unixsockets; my $file = "/tmp/memcachetest.$$.$num"; $args .= " -s $file"; push(@unixsockets, $file); } my $childpid = fork(); my $exe = get_memcached_exe(); unless ($childpid) { my $valgrind = ""; my $valgrind_args = "--quiet --error-exitcode=1 --exit-on-first-error=yes"; if ($ENV{VALGRIND_ARGS}) { $valgrind_args = $ENV{VALGRIND_ARGS}; } if ($ENV{VALGRIND_TEST}) { $valgrind = "valgrind $valgrind_args"; # NOTE: caller file stuff. $valgrind .= " $ENV{VALGRIND_EXTRA_ARGS}"; } my $cmd = "$builddir/timedrun 600 $valgrind $exe $args"; #print STDERR "RUN: $cmd\n\n"; exec $cmd; exit; # never gets here. } # unix domain sockets if ($args =~ /-s (\S+)/) { # A slow/emulated/valgrinded/etc system may take longer than a second # for the unix socket to appear. my $filename = $1; for (1..60) { my $conn = IO::Socket::UNIX->new(Peer => $filename); if ($conn) { return Memcached::Handle->new(pid => $childpid, conn => $conn, domainsocket => $filename, host => $host, port => $port); } else { croak("Failed to connect to unix socket: memcached not running") unless is_running($childpid); select undef, undef, undef, 0.20; } } croak("Failed to connect to unix domain socket: $! '$filename'") if $@; } # try to connect / find open port, only if we're not using unix domain # sockets for (1..80) { my $conn; if ($ssl_enabled) { $conn = eval qq{ IO::Socket::SSL->new(PeerAddr => "127.0.0.1:$port", SSL_verify_mode => SSL_VERIFY_NONE, SSL_cert_file => '$client_crt', SSL_key_file => '$client_key'); }; die $@ if $@; # sanity check. } else { $conn = IO::Socket::INET->new(PeerAddr => "127.0.0.1:$port"); } if ($conn) { return Memcached::Handle->new(pid => $childpid, conn => $conn, udpport => $udpport, host => $host, port => $port); } croak("Failed to connect: memcached not running") unless is_running($childpid); select undef, undef, undef, 0.25; } croak("Failed to startup/connect to memcached server."); } END { for (@unixsockets) { unlink $_; } } ############################################################################ package Memcached::Handle; use POSIX ":sys_wait_h"; sub new { my ($class, %params) = @_; return bless \%params, $class; } sub DESTROY { my $self = shift; kill 2, $self->{pid}; } sub stop { my $self = shift; kill 15, $self->{pid}; } sub graceful_stop { my $self = shift; kill 'SIGUSR1', $self->{pid}; } sub reload { my $self = shift; kill 'SIGHUP', $self->{pid}; } # -1 if the pid is actually dead. sub is_running { my $self = shift; return waitpid($self->{pid}, WNOHANG) >= 0 ? 1 : 0; } sub host { $_[0]{host} } sub port { $_[0]{port} } sub udpport { $_[0]{udpport} } sub sock { my $self = shift; if ($self->{conn} && ($self->{domainsocket} || getpeername($self->{conn}))) { return $self->{conn}; } return $self->new_sock; } sub new_sock { my $self = shift; if ($self->{domainsocket}) { return IO::Socket::UNIX->new(Peer => $self->{domainsocket}); } elsif (MemcachedTest::enabled_tls_testing()) { my $ssl_session_cache = shift; my $ssl_version = shift; return eval qq{ IO::Socket::SSL->new(PeerAddr => "$self->{host}:$self->{port}", SSL_verify_mode => IO::Socket::SSL::SSL_VERIFY_NONE, SSL_session_cache => \$ssl_session_cache, SSL_version => '$ssl_version', SSL_cert_file => '$client_crt', SSL_key_file => '$client_key'); }; } else { return IO::Socket::INET->new(PeerAddr => "$self->{host}:$self->{port}"); } } sub new_udp_sock { my $self = shift; return IO::Socket::INET->new(PeerAddr => '127.0.0.1', PeerPort => $self->{udpport}, Proto => 'udp', LocalAddr => '127.0.0.1', LocalPort => MemcachedTest::free_port('udp'), ); } 1; memcached-1.6.20/t/issue_22.t0000664000175000017500000000217214340006077012517 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 84; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached("-m 3"); my $sock = $server->sock; my $value = "B"x66560; my $key = 0; for ($key = 0; $key < 40; $key++) { print $sock "set key$key 0 0 66560\r\n$value\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key$key"); } my $first_stats = mem_stats($sock, "items"); my $first_evicted = $first_stats->{"items:31:evicted"}; # I get 1 eviction on a 32 bit binary, but 4 on a 64 binary.. # Just check that I have evictions... isnt ($first_evicted, "0", "check evicted"); print $sock "stats reset\r\n"; is (scalar <$sock>, "RESET\r\n", "Stats reset"); my $second_stats = mem_stats($sock, "items"); my $second_evicted = $second_stats->{"items:31:evicted"}; is ($second_evicted, "0", "check evicted"); for ($key = 40; $key < 80; $key++) { print $sock "set key$key 0 0 66560\r\n$value\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key$key"); } my $last_stats = mem_stats($sock, "items"); my $last_evicted = $last_stats->{"items:31:evicted"}; is ($last_evicted, "40", "check evicted"); memcached-1.6.20/t/quit.t0000664000175000017500000000112514340006077012043 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 1; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; { print $sock "quit\r\n"; # Five seconds ought to be enough to get hung up on. my $oldalarmt = alarm(5); # Verify we can't read anything. my $bytesread = -1; eval { local $SIG{'ALRM'} = sub { die "timeout" }; my $data = ""; $bytesread = sysread($sock, $data, 24), }; is($bytesread, 0, "Read after quit."); # Restore signal stuff. alarm($oldalarmt); } memcached-1.6.20/t/issue_3.t0000664000175000017500000000253014340006077012434 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 8; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $key = "del_key"; print $sock "delete $key\r\n"; is (scalar <$sock>, "NOT_FOUND\r\n", "not found on delete"); print $sock "delete $key 10\r\n"; is (scalar <$sock>, "CLIENT_ERROR bad command line format." . " Usage: delete [noreply]\r\n", "invalid delete"); print $sock "add $key 0 0 1\r\nx\r\n"; is (scalar <$sock>, "STORED\r\n", "Add before a broken delete."); print $sock "delete $key 10 noreply\r\n"; # Does not reply # is (scalar <$sock>, "ERROR\r\n", "Even more invalid delete"); print $sock "add $key 0 0 1\r\nx\r\n"; is (scalar <$sock>, "NOT_STORED\r\n", "Failed to add after failed silent delete."); print $sock "delete $key noreply\r\n"; # Will not reply, so let's do a set and check that. print $sock "set $key 0 0 1\r\nx\r\n"; is (scalar <$sock>, "STORED\r\n", "Stored a key"); print $sock "delete $key\r\n"; is (scalar <$sock>, "DELETED\r\n", "Properly deleted"); print $sock "set $key 0 0 1\r\nx\r\n"; is (scalar <$sock>, "STORED\r\n", "Stored a key"); print $sock "delete $key noreply\r\n"; # will not reply, but a subsequent add will succeed print $sock "add $key 0 0 1\r\nx\r\n"; is (scalar <$sock>, "STORED\r\n", "Add succeeded after deletion."); memcached-1.6.20/t/server.pem0000664000175000017500000001156514204760331012715 00000000000000subject= C = UK, O = OpenSSL Group, OU = FOR TESTING PURPOSES ONLY, CN = Test Server Cert issuer= C = UK, O = OpenSSL Group, OU = FOR TESTING PURPOSES ONLY, CN = OpenSSL Test Intermediate CA -----BEGIN CERTIFICATE----- MIID0DCCArigAwIBAgIIcsOElVeHzfYwDQYJKoZIhvcNAQELBQAwcDELMAkGA1UE BhMCVUsxFjAUBgNVBAoMDU9wZW5TU0wgR3JvdXAxIjAgBgNVBAsMGUZPUiBURVNU SU5HIFBVUlBPU0VTIE9OTFkxJTAjBgNVBAMMHE9wZW5TU0wgVGVzdCBJbnRlcm1l ZGlhdGUgQ0EwIBcNMTgwNjE0MTI0NjI4WhgPMjExODA2MTQxMjQ2MjhaMGQxCzAJ BgNVBAYTAlVLMRYwFAYDVQQKDA1PcGVuU1NMIEdyb3VwMSIwIAYDVQQLDBlGT1Ig VEVTVElORyBQVVJQT1NFUyBPTkxZMRkwFwYDVQQDDBBUZXN0IFNlcnZlciBDZXJ0 MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0jIZ8IZ4dIzBc+ZfdmG5 n8G3JzRX99QvIqv52s4hFVfdzoa+AciKJpo9zkegWPmfsAVNa4uVceg/ZQt6qJsu G/pxbQSZVnyjDQGtt7rgaDEbyUP0XJCnzyRdWSUjFS8yNZn4NkmZU01GlHtXdzWy dEa5PaiTIwW0HI+bjjOEhwJ1hFuFqzlKHVKHA6DBzNcl6ly0E/q2kyslbR+0hq7p NMqKvvuAxqgc//W8KvLDlKAt9D3t5zgh2+BrMPemrzjEaM97yHTogJo7+SKVDdUw YQ7Br3xfyki9u2bUYib1BMSvLezxNP0qf/iU91z4xyLmMvOXE6W0D1WHwya1CfE7 vwIDAQABo3gwdjAdBgNVHQ4EFgQU3ulCbvgfxej6rHnddMpBidwnLIIwHwYDVR0j BBgwFoAUCgNEpWg658NdblSLsvg43EA1WwUwCQYDVR0TBAIwADATBgNVHSUEDDAK BggrBgEFBQcDATAUBgNVHREEDTALgglsb2NhbGhvc3QwDQYJKoZIhvcNAQELBQAD ggEBAENMzaqJtmWED++W4KXFVwNBkQ87errBXe4jVeYKpjNb0JGMm60MS5ty54fb r27SsR2EEk3EK2rcd85RR7TEKZCn9SvPykVtVf0tru7nOptQJgSbRvxIzyyq1UcE K+BXDgN/I0f1X6qbk4Stb6uJF7yyAUabacjwKqgVifOOeKF9WJhVA8qJKoVq7HLN k+uvm0geO1I4LKeULXVnQy8kwB6twcxN8iPyO45ZxbYIVeEKaYtbj/XPoq6KsLIb 5fj+mK1r/LkWk352ksNhf73r3alF8TBcSLqnbMoy1/ZvzlI4ksp9IGWtIU+CzP/f VUjh00NOwDLd5jJbPoWW0oNp9m4= -----END CERTIFICATE----- subject= C = UK, O = OpenSSL Group, OU = FOR TESTING PURPOSES ONLY, CN = OpenSSL Test Intermediate CA issuer= C = UK, O = OpenSSL Group, OU = FOR TESTING PURPOSES ONLY, CN = OpenSSL Test Root CA -----BEGIN CERTIFICATE----- MIIEPzCCAqegAwIBAgIILsaQqJAjK4IwDQYJKoZIhvcNAQELBQAwaDELMAkGA1UE BhMCVUsxFjAUBgNVBAoMDU9wZW5TU0wgR3JvdXAxIjAgBgNVBAsMGUZPUiBURVNU SU5HIFBVUlBPU0VTIE9OTFkxHTAbBgNVBAMMFE9wZW5TU0wgVGVzdCBSb290IENB MCAXDTE4MDYxNDEyNDYyOFoYDzIxMTgwNjE0MTI0NjI4WjBwMQswCQYDVQQGEwJV SzEWMBQGA1UECgwNT3BlblNTTCBHcm91cDEiMCAGA1UECwwZRk9SIFRFU1RJTkcg UFVSUE9TRVMgT05MWTElMCMGA1UEAwwcT3BlblNTTCBUZXN0IEludGVybWVkaWF0 ZSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANIpVng2wNFJp2kF oJ6Yji25wy1YufnS8NxA82fk5OHdhGWj1CWqnQNotEqEQzcOUszQYrNxd8tEvoWk Ik4JMBVoEcgBGedchftptTNulFWodWpi1yFaqA/Nz2BsVgcCJW4C+UWDT7VeHtGU 7tYKKr35lxp6io/a4jUDQXvO2nJA9YlrxOktunMqtoZSYqUz35ZXsdkn58o8Fbqm dEpw6AqAr9aBgY5DSaGxbaX2lwNt9NvB+f9ucOqEnPP8AfTlPYc/ENwJ6u/H8RGw d1im71mu2lHjcws3aHkbluH860U3vlKWx6Ff1qdQcH98e2HwElqxCK00xya8leu4 u64nljkCAwEAAaNjMGEwHQYDVR0OBBYEFAoDRKVoOufDXW5Ui7L4ONxANVsFMB8G A1UdIwQYMBaAFDZjTeLsQUG6KL9xuLhzXVdB4pkKMA8GA1UdEwEB/wQFMAMBAf8w DgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4IBgQDZQJLA90ewVaS3E3du gSjPkQ1xsHm8H1am+7zr5oZ81J+R8XYIZgMR+9ShVo38OradiYNqDLso+4iuVdxh hzoSoQELoDXCficzWKnlAtWvwDDoczyK+/p94g3VKx14n2+GvQzoZ4kwQQgaFH1w YI6w0oH9zwoklCxvihj8D069QrYyuTT8JGZ2m0FHqVJg6teuQKFahSgwYR2CUoIb 6PrpSUQeCVCH8TPkzlRT6UgtM3ERt7+TlQ+zZ80dSf4YTAsDv9Z/CJXiF/5wZr6/ lWuFjWmX2HkpEW6Wiv5KF8QP6Ft7Z+RYua7RMtELCYvqYbWDBs7fXWGBkZ5xhB09 jCxz+F7zOeRbyzacfFq9DhxCWCRbIrdgGGE/Of2ujJtmK/2p4M6E5IsKNAI2SJBW iJXvIgQgR22ehPqy6er2Gog5LkWUwqB0kHZJJpbp1IW01IGTpD6YAJyVCEAlyMbo Kto9+wQFLT3Auv/W5h6OwxkNdfAyZBYy0ZSFk4EE8OdWWY4= -----END CERTIFICATE----- -----BEGIN RSA PRIVATE KEY----- MIIEpQIBAAKCAQEA0jIZ8IZ4dIzBc+ZfdmG5n8G3JzRX99QvIqv52s4hFVfdzoa+ AciKJpo9zkegWPmfsAVNa4uVceg/ZQt6qJsuG/pxbQSZVnyjDQGtt7rgaDEbyUP0 XJCnzyRdWSUjFS8yNZn4NkmZU01GlHtXdzWydEa5PaiTIwW0HI+bjjOEhwJ1hFuF qzlKHVKHA6DBzNcl6ly0E/q2kyslbR+0hq7pNMqKvvuAxqgc//W8KvLDlKAt9D3t 5zgh2+BrMPemrzjEaM97yHTogJo7+SKVDdUwYQ7Br3xfyki9u2bUYib1BMSvLezx NP0qf/iU91z4xyLmMvOXE6W0D1WHwya1CfE7vwIDAQABAoIBAQC2HAo1RYvfDoQc sh9LJWf5bZANO2Brqz4bP/x9AdHP+AyH/l1oliJ7R2785TmbXMppam6lGo4j3h/u n39pzOip/NWAqldfgySRBD9Jy3LZUpLMUT/JYtrAsLTfozk+BWHu5rMR9boNXgok Yqho8/DkpNGhBghUc4CUricLkL7laD3ziAHpx8yALL3tnLGOpgT9hNrA8Dm3yfUS JEfiG12ILXvq1IP+vUNuaLpTLJZuqUmLpK8v+CBYgKxfd+TDnEjul4PqhhIIFK3A xEZYQR2D/AXUwng9hP9uCbVm5lOY6vRbi9Fpbt+KRv+m25s1AnuhJFBOsL30h/Tb iCKWm/nhAoGBAO0bFqMvZHjaT2KiwOwG/Ze9NsjynFPVltiuCqNj8HE5wM6imC5J SdB+jMkgN6ERXALWrtr8Uf2pqzfeMsi6pekOOVTWLe/8c4bAZRxaCZn/BlZRysZI vB9Gb7m7Oymw5iDSqrYywgOiUu+oIiCrmPOealhmn7zmHzHaETvdL9zDAoGBAOLy DVT1csoexnuHVIWqnp7FK7lv6eOGZSdXpfJ3XYjmKJLK2hpVZe+J/mFOL1wsKSt4 0k/V0dnkHR7V4Pa4ECiCthkWMWrBVIHe7+ZnZ0ocKQSC+EEecavOiZ57S/qnUlT6 NtQP4cSy4DHzzFZdTZnn+2oymapPZpb2mvSN/GVVAoGADrIlHwwq8Aqn7Pclefuc 8DC8GoxfABs29EslQadKGdp4htYxFH1aY9/UHgsvJ36J82sW/1+wPUas5BOTljlr WxyUlRuJUVyWVH3MRouWGMNjwynipZOQhWe6OQrPye+688Ha7twKhmsjNNN4+glo u4DQGpaRxAWHXXGkq88zzj0CgYEAsICEceD7R8srnwMfb13FQ8IhQXWSuAvcO/7k 53CCZGhsgc4WVoi4YNY360G9f7gwxMiQ+NpY/Vd2dnbtIbUBjCAss9IY2OhHa0IR 3mXpZTAFjqa1oR+mVHKrgYBvFSBw3fpEDiXT9wEPcIomD709D0fmty9nZ5edOCfP WAfdlokCgYEAqXuMuAg3NMMgEv+eBfsf43v3hRwBqPYanE26wcO3GoT/S8BpB6wy vBoPZOlO5ZfsD2jaTec60GLay+MofxC7qNXIjzHOw50ry4bqHqqoQbn2cONE1k+0 ov7H2keTcG9FEGgL7dRUq3pRUo/W12WmRuDN17IEgkzAeisJnoiPtaQ= -----END RSA PRIVATE KEY----- memcached-1.6.20/t/issue_104.t0000775000175000017500000000115114340006077012577 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 6; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; # first get should miss print $sock "get foo\r\n"; is(scalar <$sock>, "END\r\n", "get foo"); # Now set and get (should hit) print $sock "set foo 0 0 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", "fooval"); my $stats = mem_stats($sock); is($stats->{cmd_get}, 2, "Should have 2 get requests"); is($stats->{get_hits}, 1, "Should have 1 hit"); is($stats->{get_misses}, 1, "Should have 1 miss"); memcached-1.6.20/t/startfile.lua0000664000175000017500000002765414427543277013431 00000000000000-- WARNING: if you cause errors during configuration reload by putting -- incompatible data into the table returned by mcp_config_pools, the daeomon -- will exit. -- TODO: fallback cache for broken/overloaded zones. -- local zone could/should be fetched from environment or local file. -- doing so allows all configuration files to be identical, simplifying consistency checks. local my_zone = 'z1' local STAT_EXAMPLE = 1 local STAT_ANOTHER = 2 function mcp_config_pools(oldss) mcp.add_stat(STAT_EXAMPLE, "example") mcp.add_stat(STAT_ANOTHER, "another") --mcp.tcp_keepalive(true) mcp.backend_connect_timeout(5.5) -- 5 and a half second timeout. -- alias mcp.backend for convenience. -- important to alias global variables in routes where speed is concerned. local srv = mcp.backend -- local zones = { 'z1', 'z2', 'z3' } -- IPs are "127" . "zone" . "pool" . "srv" local pfx = 'fooz1' local fooz1 = { srv(pfx .. 'srv1', '127.1.1.1', 11212), srv(pfx .. 'srv2', '127.1.1.2', 11212), srv(pfx .. 'srv3', '127.1.1.3', 11212), } pfx = 'fooz2' local fooz2 = { srv(pfx .. 'srv1', '127.2.1.1', 11213), srv(pfx .. 'srv2', '127.2.1.2', 11213), srv(pfx .. 'srv3', '127.2.1.3', 11213), } pfx = 'fooz3' local fooz3 = { srv(pfx .. 'srv1', '127.3.1.1', 11214), srv(pfx .. 'srv2', '127.3.1.2', 11214), srv(pfx .. 'srv3', '127.3.1.3', 11214), } pfx = 'barz1' -- zone "/bar/"-s primary zone should fail; all down. local barz1 = { srv(pfx .. 'srv1', '127.1.2.1', 11210), srv(pfx .. 'srv2', '127.1.2.2', 11210), srv(pfx .. 'srv3', '127.1.2.3', 11210), } pfx = 'barz2' local barz2 = { srv(pfx .. 'srv1', '127.2.2.1', 11215), srv(pfx .. 'srv2', '127.2.2.2', 11215), srv(pfx .. 'srv3', '127.2.2.3', 11215), } pfx = 'barz3' local barz3 = { srv(pfx .. 'srv1', '127.3.2.1', 11216), srv(pfx .. 'srv2', '127.3.2.2', 11216), srv(pfx .. 'srv3', '127.3.2.3', 11216), } -- fallback cache for any zone -- NOT USED YET pfx = 'fallz1' local fallz1 = { srv(pfx .. 'srv1', '127.0.2.1', 11212), } pfx = 'fallz2' local fallz2 = { srv(pfx .. 'srv1', '127.0.2.2', 11212), } pfx = 'fallz3' local fallz3 = { srv(pfx .. 'srv1', '127.0.2.3', 11212), } local main_zones = { foo = { z1 = fooz1, z2 = fooz2, z3 = fooz3 }, bar = { z1 = barz1, z2 = barz2, z3 = barz3 }, -- fall = { z1 = fallz1, z2 = fallz2, z3 = fallz3 }, } -- FIXME: should we copy the table to keep the pool tables around? -- does the hash selector hold a reference to the pool (but only available in main config?) -- convert the pools into hash selectors. -- TODO: is this a good place to add prefixing/hash editing? for _, subs in pairs(main_zones) do for k, v in pairs(subs) do -- next line uses a ring hash in "evcache compat" mode. note the -- hash= override to use MD5 key hashing from ketama. -- subs[k] = mcp.pool(v, { dist = mcp.dist_ring_hash, omode = "evcache", hash = mcp.dist_ring_hash.hash }) -- override the number of buckets per server. -- subs[k] = mcp.pool(v, { dist = mcp.dist_ring_hash, omode = "evcache", hash = mcp.dist_ring_hash.hash, obuckets = 240 }) -- this line uses the default (currently xxhash + jump hash) subs[k] = mcp.pool(v) -- use this next line instead for jump hash. -- the order of servers in the pool argument _must_ not change! -- adding the seed string will give a different key distribution -- for each zone. -- NOTE: 'k' may not be the right seed here: -- instead stitch main_zone's key + the sub key? -- subs[k] = mcp.pool(v, { dist = mcp.dist_jump_hash, seed = k }) -- subs[k] = mcp.pool(v, { dist = mcp.dist_jump_hash, seed = k, filter = "stop", filter_conf = "|#|" }) -- subs[k] = mcp.pool(v, { dist = mcp.dist_jump_hash, seed = k, filter = "tags", filter_conf = "{}" }) end end return main_zones end -- WORKER CODE: -- need to redefine main_zones using fetched selectors? function reqlog_factory(route) local nr = route return function(r) local res, detail = nr(r) mcp.log_req(r, res, detail) return res end end -- TODO: Fallback zone here? function failover_factory(zones, local_zone) local near_zone = zones[local_zone] local far_zones = {} -- NOTE: could shuffle/sort to re-order zone retry order -- or use 'next(far_zones, idx)' via a stored upvalue here for k, v in pairs(zones) do if k ~= local_zone then far_zones[k] = v end end return function(r) local res = near_zone(r) if res:hit() == false then -- example for mcp.log... Don't do this though :) -- mcp.log("failed to find " .. r:key() .. " in zone: " .. local_zone) --for _, zone in pairs(far_zones) do -- res = zone(r) local restable = mcp.await(r, far_zones, 1) for _, res in pairs(restable) do if res:hit() then --break return res, "failover_backup_hit" end end return restable[1], "failover_backup_miss" end -- example of making a new set request on the side. -- local nr = mcp.request("set /foo/asdf 0 0 " .. res:vlen() .. "\r\n", res) -- local nr = mcp.request("set /foo/asdf 0 0 2\r\n", "mo\r\n") -- near_zone(nr) return res, "failover_hit" -- send result back to client end end function meta_get_factory(zones, local_zone) local near_zone = zones[local_zone] -- in this test function we only fetch from the local zone. return function(r) if r:has_flag("l") == true then print("client asking for last access time") end local texists, token = r:flag_token("O") -- next example returns the previous token and replaces it. -- local texists, token = r:flag_token("O", "Odoot") if token ~= nil then print("meta opaque flag token: " .. token) end local res = near_zone(r) return res end end function meta_set_factory(zones, local_zone) local near_zone = zones[local_zone] -- in this test function we only talk to the local zone. return function(r) local res = near_zone(r) if res:code() == mcp.MCMC_CODE_NOT_FOUND then print("got meta NF response") end print("meta response line: " .. res:line()) return res end end -- SET's to main zone, issues deletes to far zones. function setinvalidate_factory(zones, local_zone) local near_zone = zones[local_zone] local far_zones = {} -- NOTE: could shuffle/sort to re-order zone retry order -- or use 'next(far_zones, idx)' via a stored upvalue here for k, v in pairs(zones) do if k ~= local_zone then far_zones[k] = v end end local new_req = mcp.request return function(r) local res = near_zone(r) if res:ok() == true then -- create a new delete request local dr = new_req("delete /testing/" .. r:key() .. "\r\n") -- example of new request from existing request -- note this isn't trimming the key so it'll make a weird one. -- local dr = new_req("set /bar/" .. r:key() .. " 0 0 " .. r:token(5) .. "\r\n", r) -- AWAIT_BACKGROUND allows us to immediately resume processing, executing the -- delete requests in the background. mcp.await(dr, far_zones, 0, mcp.AWAIT_BACKGROUND) --mcp.await(dr, far_zones, 0) mcp.log_req(r, res, "setinvalidate") -- time against the original request, since we have no result. end -- use original response for client, not DELETE's response. -- else client won't understand. return res -- send result back to client end end -- NOTE: this function is culling key prefixes. it is an error to use it -- without a left anchored (^) pattern. function prefixtrim_factory(pattern, list, default) local p = pattern local l = list local d = default local s = mcp.stat return function(r) local i, j, match = string.find(r:key(), p) local route if match ~= nil then -- remove the key prefix so we don't waste storage. r:ltrimkey(j) route = l[match] if route == nil then -- example counter: tick when default route hit. s(STAT_EXAMPLE, 1) return d(r) end end return route(r) end end function prefix_factory(pattern, list, default) local p = pattern local l = list local d = default local s = mcp.stat return function(r) local route = l[string.match(r:key(), p)] if route == nil then -- example counter: tick when default route hit. s(STAT_EXAMPLE, 1) return d(r) end return route(r) end end -- TODO: Check tail call requirements? function command_factory(map, default) local m = map local d = default return function(r) local f = map[r:command()] if f == nil then -- print("default command") return d(r) end -- testing options replacement... -- if r:command() == mcp.CMD_SET then -- r:token(4, "100") -- set exptime. -- end -- print("override command") return f(r) end end -- TODO: is the return value the average? anything special? -- walks a list of selectors and repeats the request. function walkall_factory(pool) local p = {} -- TODO: a shuffle could be useful here. for _, v in pairs(pool) do table.insert(p, v) end local x = #p return function(r) local restable = mcp.await(r, p) -- walk results and return "best" result -- print("length of await result table", #restable) for _, res in pairs(restable) do if res:ok() then return res end end -- else we return the first result. return restable[1] end end function mcp_config_routes(main_zones) -- generate the prefix routes from zones. local prefixes = {} for pfx, z in pairs(main_zones) do local failover = reqlog_factory(failover_factory(z, my_zone)) local all = walkall_factory(main_zones[pfx]) local setdel = setinvalidate_factory(z, my_zone) local map = {} map[mcp.CMD_SET] = all -- NOTE: in t/proxy.t all the backends point to the same place -- which makes replicating delete return NOT_FOUND map[mcp.CMD_DELETE] = all -- similar with ADD. will get an NOT_STORED back. -- need better routes designed for the test suite (edit the key -- prefix or something) map[mcp.CMD_ADD] = failover_factory(z, my_zone) map[mcp.CMD_MG] = meta_get_factory(z, my_zone) map[mcp.CMD_MS] = meta_set_factory(z, my_zone) prefixes[pfx] = command_factory(map, failover) end local routetop = prefix_factory("^/(%a+)/", prefixes, function(r) return "SERVER_ERROR no route\r\n" end) -- internally run parser at top of tree -- also wrap the request string with a convenience object until the C bits -- are attached to the internal parser. --mcp.attach(mcp.CMD_ANY, function (r) return routetop(r) end) mcp.attach(mcp.CMD_ANY_STORAGE, routetop) -- tagged top level attachments. ex: memcached -l tag[tagtest]:127.0.0.1:11212 -- mcp.attach(mcp.CMD_ANY_STORAGE, function (r) return "SERVER_ERROR no route\r\n" end, "tagtest") -- mcp.attach(mcp.CMD_ANY_STORAGE, function (r) return "SERVER_ERROR my route\r\n" end, "newtag") end memcached-1.6.20/t/slabhang.t0000664000175000017500000000337514340006077012651 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; plan skip_all => 'Test is flaky. Needs special hooks.'; plan tests => 74; # start up a server with 10 maximum connections my $server = new_memcached("-m 16 -o modern"); my $sock = $server->sock; my $hangsock = $server->new_sock; my $value = "B"x260144; my $key = 0; # disable the normal automover. print $sock "slabs automove 0\r\n"; is(scalar <$sock>, "OK\r\n", "automover disabled"); # These aren't set to expire. my $mget = ''; for ($key = 0; $key < 70; $key++) { $mget .= "key$key "; print $sock "set key$key 0 0 260144\r\n$value\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key$key"); } chop $mget; # Don't intend to read the results, need to fill the socket. print $hangsock "get $mget\r\n"; #sleep 8; my $stats = mem_stats($sock, "slabs"); my $source = 0; for my $key (keys %$stats) { if ($key =~ m/^(\d+):total_pages/) { my $sid = $1; if ($stats->{$key} > 10) { $source = $sid; last; } } } isnt($source, 0, "found the source slab: $source"); my $busy; my $tomove = 4; my $reassign = "slabs reassign $source 1\r\n"; while ($tomove) { $busy = 0; print $sock $reassign; my $res = scalar <$sock>; while ($res =~ m/^BUSY/) { if ($hangsock && $busy > 5) { # unjam the pipeline $hangsock->close; } last if ($busy > 10); sleep 1; $busy++; print $sock $reassign; $res = scalar <$sock>; } last if ($busy > 10); $tomove--; } ok($busy <= 10, "didn't time out moving pages"); $stats = mem_stats($sock); isnt($stats->{"slab_reassign_busy_deletes"}, "0", "deleted some busy items"); memcached-1.6.20/t/evictions.t0000664000175000017500000000155514340006077013073 00000000000000#!/usr/bin/env perl # Test the 'stats items' evictions counters. use strict; use Test::More tests => 92; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached("-m 3"); my $sock = $server->sock; my $value = "B"x66560; my $key = 0; # These aren't set to expire. for ($key = 0; $key < 40; $key++) { print $sock "set key$key 0 0 66560\r\n$value\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key$key"); } # These ones would expire in 600 seconds. for ($key = 0; $key < 50; $key++) { print $sock "set key$key 0 600 66560\r\n$value\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key$key"); } my $stats = mem_stats($sock, "items"); my $evicted = $stats->{"items:31:evicted"}; isnt($evicted, "0", "check evicted"); my $evicted_nonzero = $stats->{"items:31:evicted_nonzero"}; isnt($evicted_nonzero, "0", "check evicted_nonzero"); memcached-1.6.20/t/chunked-items.t0000664000175000017500000000750114340006077013625 00000000000000#!/usr/bin/env perl # Networked logging tests. use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached('-m 48 -o slab_chunk_max=16384'); my $sock = $server->sock; # We're testing to ensure item chaining doesn't corrupt or poorly overlap # data, so create a non-repeating pattern. my @parts = (); for (1 .. 8000) { push(@parts, $_); } my $pattern = join(':', @parts); my $plen = length($pattern); print $sock "set pattern 0 0 $plen\r\n$pattern\r\n"; is(scalar <$sock>, "STORED\r\n", "stored pattern successfully"); mem_get_is($sock, "pattern", $pattern); for (1..5) { my $size = 400 * 1024; my $data = "x" x $size; print $sock "set foo$_ 0 0 $size\r\n$data\r\n"; my $res = <$sock>; is($res, "STORED\r\n", "stored some big items: $size"); } { my $max = 1024 * 1024; my $big = "a big value that's > .5M and < 1M. "; while (length($big) * 2 < $max) { $big = $big . $big; } my $biglen = length($big); for (1..100) { print $sock "set toast$_ 0 0 $biglen\r\n$big\r\n"; is(scalar <$sock>, "STORED\r\n", "stored big"); mem_get_is($sock, "toast$_", $big); } } # Test a wide range of sets. { my $len = 1024 * 200; while ($len < 1024 * 1024) { my $val = "B" x $len; print $sock "set foo_$len 0 0 $len\r\n$val\r\n"; is(scalar <$sock>, "STORED\r\n", "stored size $len"); $len += 2048; } } # Test long appends and prepends. # Note: memory bloats like crazy if we use one test per request. { my $str = 'seedstring'; my $len = length($str); print $sock "set appender 0 0 $len\r\n$str\r\n"; is(scalar <$sock>, "STORED\r\n", "stored seed string for append"); my $unexpected = 0; for my $part (@parts) { # reduce required loops but still have a pattern. my $todo = $part . "x" x 10; $str .= $todo; my $len = length($todo); print $sock "append appender 0 0 $len\r\n$todo\r\n"; is(scalar <$sock>, "STORED\r\n", "append $todo size $len"); print $sock "get appender\r\n"; my $header = scalar <$sock>; my $body = scalar <$sock>; my $end = scalar <$sock>; $unexpected++ unless $body eq "$str\r\n"; } is($unexpected, 0, "No unexpected results during appends\n"); # Now test appending a chunked item to a chunked item. $len = length($str); print $sock "append appender 0 0 $len\r\n$str\r\n"; is(scalar <$sock>, "STORED\r\n", "append large string size $len"); mem_get_is($sock, "appender", $str . $str); print $sock "delete appender\r\n"; is(scalar <$sock>, "DELETED\r\n", "removed appender key"); } { my $str = 'seedstring'; my $len = length($str); print $sock "set prepender 0 0 $len\r\n$str\r\n"; is(scalar <$sock>, "STORED\r\n", "stored seed string for append"); my $unexpected = 0; for my $part (@parts) { # reduce required loops but still have a pattern. $part .= "x" x 10; $str = $part . $str; my $len = length($part); print $sock "prepend prepender 0 0 $len\r\n$part\r\n"; is(scalar <$sock>, "STORED\r\n", "prepend $part size $len"); print $sock "get prepender\r\n"; my $header = scalar <$sock>; my $body = scalar <$sock>; my $end = scalar <$sock>; $unexpected++ unless $body eq "$str\r\n"; } is($unexpected, 0, "No unexpected results during prepends\n"); # Now test prepending a chunked item to a chunked item. $len = length($str); print $sock "prepend prepender 0 0 $len\r\n$str\r\n"; is(scalar <$sock>, "STORED\r\n", "prepend large string size $len"); mem_get_is($sock, "prepender", $str . $str); print $sock "delete prepender\r\n"; is(scalar <$sock>, "DELETED\r\n", "removed prepender key"); } done_testing(); memcached-1.6.20/t/binary-sasl.t0000775000175000017500000004273614340006077013325 00000000000000#!/usr/bin/env perl use strict; use warnings; use Cwd; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $supports_sasl = supports_sasl(); use Test::More; if (supports_sasl()) { if ($ENV{'RUN_SASL_TESTS'}) { plan tests => 34; } else { plan skip_all => 'Skipping SASL tests'; exit 0; } } else { plan tests => 1; eval { my $server = new_memcached("-S"); }; ok($@, "Died with illegal -S args when SASL is not supported."); exit 0; } eval { my $server = new_memcached("-S -B auto"); }; ok($@, "SASL shouldn't be used with protocol auto negotiate"); eval { my $server = new_memcached("-S -B ascii"); }; ok($@, "SASL isn't implemented in the ascii protocol"); eval { my $server = new_memcached("-S -B binary -B ascii"); }; ok($@, "SASL isn't implemented in the ascii protocol"); # Based almost 100% off testClient.py which is: # Copyright (c) 2007 Dustin Sallings # Command constants use constant CMD_GET => 0x00; use constant CMD_SET => 0x01; use constant CMD_ADD => 0x02; use constant CMD_REPLACE => 0x03; use constant CMD_DELETE => 0x04; use constant CMD_INCR => 0x05; use constant CMD_DECR => 0x06; use constant CMD_QUIT => 0x07; use constant CMD_FLUSH => 0x08; use constant CMD_GETQ => 0x09; use constant CMD_NOOP => 0x0A; use constant CMD_VERSION => 0x0B; use constant CMD_GETK => 0x0C; use constant CMD_GETKQ => 0x0D; use constant CMD_APPEND => 0x0E; use constant CMD_PREPEND => 0x0F; use constant CMD_STAT => 0x10; use constant CMD_SETQ => 0x11; use constant CMD_ADDQ => 0x12; use constant CMD_REPLACEQ => 0x13; use constant CMD_DELETEQ => 0x14; use constant CMD_INCREMENTQ => 0x15; use constant CMD_DECREMENTQ => 0x16; use constant CMD_QUITQ => 0x17; use constant CMD_FLUSHQ => 0x18; use constant CMD_APPENDQ => 0x19; use constant CMD_PREPENDQ => 0x1A; use constant CMD_SASL_LIST_MECHS => 0x20; use constant CMD_SASL_AUTH => 0x21; use constant CMD_SASL_STEP => 0x22; use constant ERR_AUTH_ERROR => 0x20; # REQ and RES formats are divided even though they currently share # the same format, since they _could_ differ in the future. use constant REQ_PKT_FMT => "CCnCCnNNNN"; use constant RES_PKT_FMT => "CCnCCnNNNN"; use constant INCRDECR_PKT_FMT => "NNNNN"; use constant MIN_RECV_BYTES => length(pack(RES_PKT_FMT)); use constant REQ_MAGIC => 0x80; use constant RES_MAGIC => 0x81; my $pwd=getcwd; $ENV{'SASL_CONF_PATH'} = "$pwd/t/sasl"; my $server = new_memcached('-B binary -U 0 -S -l 127.0.0.1 '); my $mc = MC::Client->new; my $check = sub { my ($key, $orig_val) = @_; my ($status, $val, $cas) = $mc->get($key); if ($val =~ /^\d+$/) { cmp_ok($val,'==', $orig_val, "$val = $orig_val"); } else { cmp_ok($val, 'eq', $orig_val, "$val = $orig_val"); } }; my $set = sub { my ($key, $orig_value, $exp) = @_; $exp = defined $exp ? $exp : 0; my ($status, $rv)= $mc->set($key, $orig_value, $exp); $check->($key, $orig_value); }; my $empty = sub { my $key = shift; my ($status,$rv) =()= eval { $mc->get($key) }; #if ($status == ERR_AUTH_ERROR) { # ok($@->auth_error, "Not authorized to connect"); #} #else { # ok($@->not_found, "We got a not found error when we expected one"); #} if ($status) { ok($@->not_found, "We got a not found error when we expected one"); } }; my $delete = sub { my ($key, $when) = @_; $mc->delete($key, $when); $empty->($key); }; # BEGIN THE TEST ok($server, "started the server"); my $v = $mc->version; ok(defined $v && length($v), "Proper version: $v"); # list mechs my $mechs= $mc->list_mechs(); Test::More::cmp_ok($mechs, 'eq', 'CRAM-MD5 PLAIN', "list_mechs $mechs"); # this should fail, not authenticated { my ($status, $val)= $mc->set('x', "somevalue"); ok($status, "this fails to authenticate"); cmp_ok($status,'==',ERR_AUTH_ERROR, "error code matches"); } $empty->('x'); { my $mc = MC::Client->new; my ($status, $val) = $mc->delete('x'); ok($status, "this fails to authenticate"); cmp_ok($status,'==',ERR_AUTH_ERROR, "error code matches"); } $empty->('x'); { my $mc = MC::Client->new; my ($status, $val)= $mc->set('x', "somevalue"); ok($status, "this fails to authenticate"); cmp_ok($status,'==',ERR_AUTH_ERROR, "error code matches"); } $empty->('x'); { my $mc = MC::Client->new; my ($status, $val)= $mc->flush('x'); ok($status, "this fails to authenticate"); cmp_ok($status,'==',ERR_AUTH_ERROR, "error code matches"); } $empty->('x'); # Build the auth DB for testing. my $sasldb = '/tmp/test-memcached.sasldb'; unlink $sasldb; my $saslpasswd_path; for my $dir (split(/:/, $ENV{PATH}), "/usr/bin", "/usr/sbin", "/usr/local/bin", "/usr/local/sbin", ) { my $exe = $dir . '/saslpasswd2'; if (-x $exe) { $saslpasswd_path = $exe; last; } } die "no saslpasswd2 found" unless $saslpasswd_path; my $sasl_realm = 'memcached.realm'; system("echo testpass | $saslpasswd_path -a memcached -u $sasl_realm -c -p testuser"); $mc = MC::Client->new; # Attempt a bad auth mech. is ($mc->authenticate('testuser', 'testpass', "X" x 40), 0x4, "bad mech"); # Attempt bad authentication. is ($mc->authenticate('testuser', 'wrongpassword'), 0x20, "bad auth"); # Now try good authentication and make the tests work. is ($mc->authenticate('testuser', 'testpass'), 0, "authenticated"); # these should work { my ($status, $val)= $mc->set('x', "somevalue"); ok(! $status); } $check->('x','somevalue'); { my ($status, $val)= $mc->delete('x'); ok(! $status); } $empty->('x'); { my ($status, $val)= $mc->set('x', "somevalue"); ok(! $status); } $check->('x','somevalue'); { my ($status, $val)= $mc->flush('x'); ok(! $status); } $empty->('x'); { my $mc = MC::Client->new; # Attempt bad authentication. is ($mc->authenticate('testuser', 'wrongpassword'), 0x20, "bad auth"); # This should fail because $mc is not authenticated my ($status, $val)= $mc->set('x', "somevalue"); ok($status, "this fails to authenticate"); cmp_ok($status,'==',ERR_AUTH_ERROR, "error code matches"); } $empty->('x', 'somevalue'); { my $mc = MC::Client->new; # Attempt bad authentication. is ($mc->authenticate('testuser', 'wrongpassword'), 0x20, "bad auth"); # Mix an authenticated connection and an unauthenticated connection to # confirm c->authenticated is not shared among connections my $mc2 = MC::Client->new; is ($mc2->authenticate('testuser', 'testpass'), 0, "authenticated"); my ($status, $val)= $mc2->set('x', "somevalue"); ok(! $status); # This should fail because $mc is not authenticated ($status, $val)= $mc->set('x', "somevalue"); ok($status, "this fails to authenticate"); cmp_ok($status,'==',ERR_AUTH_ERROR, "error code matches"); } { my $mc = MC::Client->new; is ($mc->sasl_step('testuser', 'testpass'), 0x20, "sasl_step_fails_no_segfault"); } # check the SASL stats, make sure they track things correctly # note: the enabled or not is presence checked in stats.t # while authenticated, get current counter # # My initial approach was going to be to get current counts, reauthenticate # and fail, followed by a reauth successfully so I'd know what happened. # Reauthentication is currently unsupported, so it doesn't work that way at the # moment. Adding tests may break this. { my %stats = $mc->stats(''); is ($stats{'auth_cmds'}, 6, "auth commands counted"); is ($stats{'auth_errors'}, 4, "auth errors correct"); } # Along with the assertion added to the code to verify we're staying # within bounds when we do a stats detail dump (detail turned on at # the top). # my %stats = $mc->stats('detail dump'); # ###################################################################### # Test ends around here. # ###################################################################### package MC::Client; use strict; use warnings; use fields qw(socket); use IO::Socket::INET; use constant ERR_AUTH_ERROR => 0x20; sub new { my $self = shift; my ($s) = @_; $s = $server unless defined $s; my $sock = $s->sock; $self = fields::new($self); $self->{socket} = $sock; return $self; } sub authenticate { my ($self, $user, $pass, $mech)= @_; $mech ||= 'PLAIN'; my $buf = sprintf("%c%s@%s%c%s", 0, $user, $sasl_realm, 0, $pass); my ($status, $rv, undef) = $self->_do_command(::CMD_SASL_AUTH, $mech, $buf, ''); return $status; } sub sasl_step { my ($self, $user, $pass, $mech)= @_; $mech ||= 'PLAIN'; my $buf = sprintf("%c%s@%s%c%s", 0, $user, $sasl_realm, 0, $pass); my ($status, $rv, undef) = $self->_do_command(::CMD_SASL_STEP, $mech, $buf, ''); return $status; } sub list_mechs { my ($self)= @_; my ($status, $rv, undef) = $self->_do_command(::CMD_SASL_LIST_MECHS, '', '', ''); return join(" ", sort(split(/\s+/, $rv))); } sub build_command { my $self = shift; die "Not enough args to send_command" unless @_ >= 4; my ($cmd, $key, $val, $opaque, $extra_header, $cas) = @_; $extra_header = '' unless defined $extra_header; my $keylen = length($key); my $vallen = length($val); my $extralen = length($extra_header); my $datatype = 0; # field for future use my $reserved = 0; # field for future use my $totallen = $keylen + $vallen + $extralen; my $ident_hi = 0; my $ident_lo = 0; if ($cas) { $ident_hi = int($cas / 2 ** 32); $ident_lo = int($cas % 2 ** 32); } my $msg = pack(::REQ_PKT_FMT, ::REQ_MAGIC, $cmd, $keylen, $extralen, $datatype, $reserved, $totallen, $opaque, $ident_hi, $ident_lo); my $full_msg = $msg . $extra_header . $key . $val; return $full_msg; } sub send_command { my $self = shift; die "Not enough args to send_command" unless @_ >= 4; my ($cmd, $key, $val, $opaque, $extra_header, $cas) = @_; my $full_msg = $self->build_command($cmd, $key, $val, $opaque, $extra_header, $cas); my $sent = $self->{socket}->send($full_msg); die("Send failed: $!") unless $sent; if($sent != length($full_msg)) { die("only sent $sent of " . length($full_msg) . " bytes"); } } sub flush_socket { my $self = shift; $self->{socket}->flush; } # Send a silent command and ensure it doesn't respond. sub send_silent { my $self = shift; die "Not enough args to send_silent" unless @_ >= 4; my ($cmd, $key, $val, $opaque, $extra_header, $cas) = @_; $self->send_command($cmd, $key, $val, $opaque, $extra_header, $cas); $self->send_command(::CMD_NOOP, '', '', $opaque + 1); my ($ropaque, $status, $data) = $self->_handle_single_response; Test::More::is($ropaque, $opaque + 1); } sub silent_mutation { my $self = shift; my ($cmd, $key, $value) = @_; $empty->($key); my $extra = pack "NN", 82, 0; $mc->send_silent($cmd, $key, $value, 7278552, $extra, 0); $check->($key, $value); } sub _handle_single_response { my $self = shift; my $myopaque = shift; $self->{socket}->recv(my $response, ::MIN_RECV_BYTES); my ($magic, $cmd, $keylen, $extralen, $datatype, $status, $remaining, $opaque, $ident_hi, $ident_lo) = unpack(::RES_PKT_FMT, $response); return ($opaque, '', '', '', 0) if not defined $remaining; return ($opaque, '', '', '', 0) if ($remaining == 0); # fetch the value my $rv=""; while($remaining - length($rv) > 0) { $self->{socket}->recv(my $buf, $remaining - length($rv)); $rv .= $buf; } if(length($rv) != $remaining) { my $found = length($rv); die("Expected $remaining bytes, got $found"); } my $cas = ($ident_hi * 2 ** 32) + $ident_lo; #if ($status) { #die MC::Error->new($status, $rv); #} return ($opaque, $status, $rv, $cas, $keylen); } sub _do_command { my $self = shift; die unless @_ >= 3; my ($cmd, $key, $val, $extra_header, $cas) = @_; $extra_header = '' unless defined $extra_header; my $opaque = int(rand(2**32)); $self->send_command($cmd, $key, $val, $opaque, $extra_header, $cas); my (undef, $status, $rv, $rcas) = $self->_handle_single_response($opaque); return ($status, $rv, $rcas); } sub _incrdecr_header { my $self = shift; my ($amt, $init, $exp) = @_; my $amt_hi = int($amt / 2 ** 32); my $amt_lo = int($amt % 2 ** 32); my $init_hi = int($init / 2 ** 32); my $init_lo = int($init % 2 ** 32); my $extra_header = pack(::INCRDECR_PKT_FMT, $amt_hi, $amt_lo, $init_hi, $init_lo, $exp); return $extra_header; } sub _incrdecr { my $self = shift; my ($cmd, $key, $amt, $init, $exp) = @_; my ($status, $data, undef) = $self->_do_command($cmd, $key, '', $self->_incrdecr_header($amt, $init, $exp)); my $header = substr $data, 0, 8, ''; my ($resp_hi, $resp_lo) = unpack "NN", $header; my $resp = ($resp_hi * 2 ** 32) + $resp_lo; return $resp; } sub silent_incrdecr { my $self = shift; my ($cmd, $key, $amt, $init, $exp) = @_; my $opaque = 8275753; $mc->send_silent($cmd, $key, '', $opaque, $mc->_incrdecr_header($amt, $init, $exp)); } sub stats { my $self = shift; my $key = shift; my $cas = 0; my $opaque = int(rand(2**32)); $self->send_command(::CMD_STAT, $key, '', $opaque, '', $cas); my %rv = (); my $found_key = ''; my $found_val = ''; my $status= 0; do { my ($op, $status, $data, $cas, $keylen) = $self->_handle_single_response($opaque); if ($keylen > 0) { $found_key = substr($data, 0, $keylen); $found_val = substr($data, $keylen); $rv{$found_key} = $found_val; } else { $found_key = ''; } } while($found_key ne ''); return %rv; } sub get { my $self = shift; my $key = shift; my ($status, $rv, $cas) = $self->_do_command(::CMD_GET, $key, '', ''); my $header = substr $rv, 0, 4, ''; my $flags = unpack("N", $header); return ($status, $rv); } sub get_multi { my $self = shift; my @keys = @_; for (my $i = 0; $i < @keys; $i++) { $self->send_command(::CMD_GETQ, $keys[$i], '', $i, '', 0); } my $terminal = @keys + 10; $self->send_command(::CMD_NOOP, '', '', $terminal); my %return; my $status = 0; while (1) { my ($opaque, $status, $data) = $self->_handle_single_response; last if $opaque == $terminal; my $header = substr $data, 0, 4, ''; my $flags = unpack("N", $header); $return{$keys[$opaque]} = [$flags, $data]; } return %return if wantarray; return \%return; } sub version { my $self = shift; return $self->_do_command(::CMD_VERSION, '', ''); } sub flush { my $self = shift; return $self->_do_command(::CMD_FLUSH, '', ''); } sub add { my $self = shift; my ($key, $val, $flags, $expire) = @_; my $extra_header = pack "NN", $flags, $expire; my $cas = 0; return $self->_do_command(::CMD_ADD, $key, $val, $extra_header, $cas); } sub set { my $self = shift; my $flags = 0; my $cas = 0; my ($key, $val, $expire) = @_; $expire = defined $expire ? $expire : 0; my $extra_header = pack "NN", $flags, $expire; return $self->_do_command(::CMD_SET, $key, $val, $extra_header, $cas); } sub _append_prepend { my $self = shift; my ($cmd, $key, $val, $cas) = @_; return $self->_do_command($cmd, $key, $val, '', $cas); } sub replace { my $self = shift; my ($key, $val, $flags, $expire) = @_; my $extra_header = pack "NN", $flags, $expire; my $cas = 0; return $self->_do_command(::CMD_REPLACE, $key, $val, $extra_header, $cas); } sub delete { my $self = shift; my ($key) = @_; return $self->_do_command(::CMD_DELETE, $key, ''); } sub incr { my $self = shift; my ($key, $amt, $init, $exp) = @_; $amt = 1 unless defined $amt; $init = 0 unless defined $init; $exp = 0 unless defined $exp; return $self->_incrdecr(::CMD_INCR, $key, $amt, $init, $exp); } sub decr { my $self = shift; my ($key, $amt, $init, $exp) = @_; $amt = 1 unless defined $amt; $init = 0 unless defined $init; $exp = 0 unless defined $exp; return $self->_incrdecr(::CMD_DECR, $key, $amt, $init, $exp); } sub noop { my $self = shift; return $self->_do_command(::CMD_NOOP, '', ''); } package MC::Error; use strict; use warnings; use constant ERR_UNKNOWN_CMD => 0x81; use constant ERR_NOT_FOUND => 0x1; use constant ERR_EXISTS => 0x2; use constant ERR_TOO_BIG => 0x3; use constant ERR_EINVAL => 0x4; use constant ERR_NOT_STORED => 0x5; use constant ERR_DELTA_BADVAL => 0x6; use constant ERR_AUTH_ERROR => 0x20; use overload '""' => sub { my $self = shift; return "Memcache Error ($self->[0]): $self->[1]"; }; sub new { my $class = shift; my $error = [@_]; my $self = bless $error, (ref $class || $class); return $self; } sub not_found { my $self = shift; return $self->[0] == ERR_NOT_FOUND; } sub exists { my $self = shift; return $self->[0] == ERR_EXISTS; } sub too_big { my $self = shift; return $self->[0] == ERR_TOO_BIG; } sub delta_badval { my $self = shift; return $self->[0] == ERR_DELTA_BADVAL; } sub auth_error { my $self = shift; return $self->[0] == ERR_AUTH_ERROR; } unlink $sasldb; # vim: filetype=perl memcached-1.6.20/t/issue_68.t0000664000175000017500000000077514340006077012540 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 996; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; for (my $keyi = 1; $keyi < 250; $keyi++) { my $key = "x" x $keyi; print $sock "set $key 0 0 1\r\n9\r\n"; is (scalar <$sock>, "STORED\r\n", "stored $key"); mem_get_is($sock, $key, "9"); print $sock "incr $key 1\r\n"; is (scalar <$sock>, "10\r\n", "incr $key to 10"); mem_get_is($sock, $key, "10"); } memcached-1.6.20/t/authfile0000664000175000017500000000002314204760331012413 00000000000000foo:bar baaaz:quux memcached-1.6.20/t/issue_41.t0000664000175000017500000000173014340006077012517 00000000000000#!/usr/bin/env perl use strict; use warnings; use POSIX qw(ceil); use Test::More tests => 691; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $factor = 2; my $val = "x" x $factor; my $key = ''; # SET items of diverse size to the daemon so it can attempt # to return a large stats output for slabs for (my $i=0; $i<69; $i++) { for (my $j=0; $j<10; $j++) { $key = "$i:$j"; print $sock "set key$key 0 0 $factor\r\n$val\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key$key"); } $factor *= 1.2; $factor = ceil($factor); $val = "x" x $factor; } # This request will kill the daemon if it has not allocated # enough memory internally. my $stats = mem_stats($sock, "slabs"); # Verify whether the daemon is still running or not by asking # it for statistics. print $sock "version\r\n"; my $v = scalar <$sock>; ok(defined $v && length($v), "memcached didn't respond"); memcached-1.6.20/t/issue_192.t0000664000175000017500000000105014340006077012601 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 2; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; ok($server->new_sock, "opened new socket"); print $sock "\x80\x12\x00\x01\x08\x00\x00\x00\xff\xff\xff\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x01\x00\x00\x00\x00\x00\x00\x00\x00\x000\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"; sleep 0.5; ok($server->new_sock, "failed to open new socket"); memcached-1.6.20/t/maxconns.t0000775000175000017500000000276014340006077012720 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); test_maxconns($server); my $ext_path; if (supports_extstore()) { $ext_path = "/tmp/extstore.$$"; my $server = new_memcached("-m 64 -U 0 -o ext_path=$ext_path:64m"); test_maxconns($server); } sub test_maxconns { my $server = shift; my $stat_sock = $server->sock; my @sockets = (); my $num_sockets; my $rejected_conns = 0; my $stats; for (1 .. 1024) { my $sock = $server->new_sock; if (defined($sock)) { push(@sockets, $sock); $stats = mem_stats($stat_sock); if ($stats->{rejected_connections} > $rejected_conns) { $rejected_conns = $stats->{rejected_connections}; my $buffer = ""; my $length = 31; my $res = recv($sock, $buffer, $length, 0); if (not $buffer eq '') { is($buffer, "ERROR Too many open connections", "Got expected response from the server"); } } } } my $failed = 1; for (1 .. 5) { $stats = mem_stats($stat_sock); if ($stats->{rejected_connections} != 0) { $failed = 0; last; } sleep 1; } is($failed, 0, "rejected connections were observed."); for my $s (@sockets) { $s->close(); } $server->stop; $stat_sock->close(); } done_testing(); END { unlink $ext_path if $ext_path; } memcached-1.6.20/t/ssl_settings.t0000664000175000017500000000201514340006077013601 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; use Cwd; if (!enabled_tls_testing()) { plan skip_all => 'SSL testing is not enabled'; exit 0; } my $server = new_memcached(); my $settings = mem_stats($server->sock, ' settings'); my $cert = getcwd ."/t/". MemcachedTest::SRV_CRT; my $key = getcwd ."/t/". MemcachedTest::SRV_KEY; is($settings->{'ssl_enabled'}, 'yes'); is($settings->{'ssl_session_cache'}, 'no'); is($settings->{'ssl_kernel_tls'}, 'no'); is($settings->{'ssl_chain_cert'}, $cert); is($settings->{'ssl_key'}, $key); is($settings->{'ssl_verify_mode'}, 0); is($settings->{'ssl_keyformat'}, 1); is($settings->{'ssl_ciphers'}, 'NULL'); is($settings->{'ssl_ca_cert'}, 'NULL'); is($settings->{'ssl_wbuf_size'}, 16384); is($settings->{'ssl_min_version'}, 'tlsv1.2'); $server->DESTROY(); $server = new_memcached("-o ssl_wbuf_size=64"); $settings = mem_stats($server->sock, ' settings'); is($settings->{'ssl_wbuf_size'}, 65536); done_testing(); memcached-1.6.20/t/issue_152.t0000664000175000017500000000061214340006077012600 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 2; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $key = "a"x251; print $sock "set a 1 0 1\r\na\r\n"; is (scalar <$sock>, "STORED\r\n", "Stored key"); print $sock "get a $key\r\n"; is (scalar <$sock>, "CLIENT_ERROR bad command line format\r\n", "illegal key"); memcached-1.6.20/t/error-extstore.t0000664000175000017500000000735714340006077014102 00000000000000#!/usr/bin/env perl # Test the "Error on get" path for extstore. # the entire error handling code for process_get_command() never worked, and # would infinite loop. get_extstore() can hit it sometimes. use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $ext_path; if (!supports_extstore()) { plan skip_all => 'extstore not enabled'; exit 0; } $ext_path = "/tmp/extstore.$$"; my $server = new_memcached("-m 64 -I 4m -U 0 -o ext_page_size=8,ext_wbuf_size=8,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path:64m,slab_automove=0,ext_compact_under=1,ext_max_sleep=100000"); my $sock = $server->sock; # Wait until all items have flushed sub wait_for_ext { my $sum = 1; while ($sum != 0) { my $s = mem_stats($sock, "items"); $sum = 0; for my $key (keys %$s) { if ($key =~ m/items:(\d+):number/) { # Ignore classes which can contain extstore items next if $1 < 3; $sum += $s->{$key}; } } sleep 1 if $sum != 0; } } # We're testing to ensure item chaining doesn't corrupt or poorly overlap # data, so create a non-repeating pattern. my @parts = (); for (1 .. 8000) { push(@parts, $_); } my $pattern = join(':', @parts); my $plen = length($pattern); # Set some large items and let them flush to extstore. for (1..5) { my $size = 3000 * 1024; my $data = "x" x $size; print $sock "set foo$_ 0 0 $size\r\n$data\r\n"; my $res = <$sock>; is($res, "STORED\r\n", "stored some big items"); } wait_for_ext(); { my $long_key = "f" x 512; print $sock "get foo1 foo2 foo3 $long_key\r\n"; ok(scalar <$sock> =~ /CLIENT_ERROR bad command line format/, 'long key fails'); my $stats = mem_stats($sock); cmp_ok($stats->{get_aborted_extstore}, '>', 1, 'some extstore queries aborted'); } # Infinite loop: if we aborted some extstore requests, the next request would hang # the daemon. { my $size = 3000 * 1024; my $data = "x" x $size; mem_get_is($sock, "foo1", $data); } # Disable automatic page balancing, then move enough pages that the large # items can no longer be loaded from extstore { print $sock "slabs automove 0\r\n"; my $res = <$sock>; my $source = 0; while (1) { print $sock "slabs reassign $source 1\r\n"; $res = <$sock>; if ($res =~ m/NOSPARE/) { $source = -1; my $stats = mem_stats($sock, 'slabs'); for my $key (grep { /total_pages/ } keys %$stats) { if ($key =~ m/(\d+):total_pages/) { next if $1 < 3; $source = $1 if $stats->{$key} > 1; } } last if $source == -1; } select undef, undef, undef, 0.10; } } # fetching the large keys should now fail. { print $sock "get foo1\r\n"; my $res = <$sock>; $res =~ s/[\r\n]//g; is($res, 'SERVER_ERROR out of memory writing get response', 'can no longer read back item'); my $stats = mem_stats($sock); is($stats->{get_oom_extstore}, 1, 'check extstore oom counter'); } # Leaving this for future generations. # The process_get_command() function had several memory leaks. my $LEAK_TEST = 0; if ($LEAK_TEST) { my $tries = 0; while ($tries) { print $sock "slabs reassign 1 39\r\n"; my $res = <$sock>; if ($res =~ m/BUSY/) { select undef, undef, undef, 0.10; } else { $tries--; } } my $long_key = "f" x 512; while (1) { print $sock "get foo1 foo2 foo3 $long_key\r\n"; my $res = <$sock>; } } done_testing(); END { unlink $ext_path if $ext_path; } memcached-1.6.20/t/udp.t0000775000175000017500000002400014340006077011651 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 67; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; use constant IS_ASCII => 0; use constant IS_BINARY => 1; use constant ENTRY_EXISTS => 0; use constant ENTRY_MISSING => 1; use constant BIN_REQ_MAGIC => 0x80; use constant BIN_RES_MAGIC => 0x81; use constant CMD_GET => 0x00; use constant CMD_SET => 0x01; use constant CMD_ADD => 0x02; use constant CMD_REPLACE => 0x03; use constant CMD_DELETE => 0x04; use constant CMD_INCR => 0x05; use constant CMD_DECR => 0x06; use constant CMD_APPEND => 0x0E; use constant CMD_PREPEND => 0x0F; use constant REQ_PKT_FMT => "CCnCCnNNNN"; use constant RES_PKT_FMT => "CCnCCnNNNN"; use constant INCRDECR_PKT_FMT => "NNNNN"; use constant MIN_RECV_BYTES => length(pack(RES_PKT_FMT)); my $server = new_memcached("-l 127.0.0.1"); my $sock = $server->sock; # set foo (and should get it) print $sock "set foo 0 0 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", "fooval"); my $usock = $server->new_udp_sock or die "Can't bind : $@\n"; # testing sequence of request ids for my $offt (1, 1, 2) { my $req = 160 + $offt; my $res = send_udp_request($usock, $req, "get foo\r\n"); ok($res, "got result"); is(keys %$res, 1, "one key (one packet)"); ok($res->{0}, "only got seq number 0"); is(substr($res->{0}, 8), "VALUE foo 0 6\r\nfooval\r\nEND\r\n"); is(hexify(substr($res->{0}, 0, 2)), hexify(pack("n", $req)), "udp request number in response ($req) is correct"); } my $bvalue; my $bsize = 20000; { my @chars = ("C".."Z"); for (1 .. $bsize) { $bvalue .= $chars[rand @chars]; } } # set and test a multi-packet value { print $sock "set bigvalue 0 0 $bsize\r\n$bvalue\r\n"; is(scalar <$sock>, "STORED\r\n", "stored bigvalue"); mem_get_is($sock, "bigvalue", $bvalue); my $res = send_udp_request($usock, 53, "get bigvalue\r\n"); ok($res, "got result"); my $resp = construct_udp_message($res); is($resp, "VALUE bigvalue 0 $bsize\r\n$bvalue\r\nEND\r\n"); } # op tests for my $prot (::IS_ASCII,::IS_BINARY) { udp_set_test($prot,45,"aval$prot","1",0,0); udp_set_test($prot,45,"bval$prot","abcd" x 1024,0,0); udp_get_test($prot,45,"aval$prot","1",::ENTRY_EXISTS); udp_get_test($prot,45,"404$prot","1",::ENTRY_MISSING); udp_incr_decr_test($prot,45,"aval$prot","1","incr",1); udp_incr_decr_test($prot,45,"aval$prot","1","decr",2); udp_delete_test($prot,45,"aval$prot"); } sub udp_set_test { my ($protocol, $req_id, $key, $value, $flags, $exp) = @_; my $req = ""; my $val_len = length($value); if ($protocol == ::IS_ASCII) { $req = "set $key $flags $exp $val_len\r\n$value\r\n"; } elsif ($protocol == ::IS_BINARY) { my $key_len = length($key); my $extra = pack "NN",$flags,$exp; my $extra_len = length($extra); my $total_len = $val_len + $extra_len + $key_len; $req = pack(::REQ_PKT_FMT, ::BIN_REQ_MAGIC, ::CMD_SET, $key_len, $extra_len, 0, 0, $total_len, 0, 0, 0); $req .= $extra . $key . $value; } my $datagrams = send_udp_request($usock, $req_id, $req); my $resp = construct_udp_message($datagrams); if ($protocol == ::IS_ASCII) { is($resp,"STORED\r\n","Store key $key using ASCII protocol"); } elsif ($protocol == ::IS_BINARY) { my ($resp_magic, $resp_op_code, $resp_key_len, $resp_extra_len, $resp_data_type, $resp_status, $resp_total_len, $resp_opaque, $resp_ident_hi, $resp_ident_lo) = unpack(::RES_PKT_FMT, $resp); is($resp_status,"0","Store key $key using binary protocol"); } } sub udp_get_test { my ($protocol, $req_id, $key, $value, $exists) = @_; my $key_len = length($key); my $value_len = length($value); my $req = ""; if ($protocol == ::IS_ASCII) { $req = "get $key\r\n"; } elsif ($protocol == ::IS_BINARY) { $req = pack(::REQ_PKT_FMT, ::BIN_REQ_MAGIC, ::CMD_GET, $key_len, 0, 0, 0, $key_len, 0, 0, 0); $req .= $key; } my $datagrams = send_udp_request($usock, $req_id, $req); my $resp = construct_udp_message($datagrams); if ($protocol == ::IS_ASCII) { if ($exists == ::ENTRY_EXISTS) { is($resp,"VALUE $key 0 $value_len\r\n$value\r\nEND\r\n","Retrieve entry with key $key using ASCII protocol"); } else { is($resp,"END\r\n","Retrieve non existing entry with key $key using ASCII protocol"); } } elsif ($protocol == ::IS_BINARY) { my ($resp_magic, $resp_op_code, $resp_key_len, $resp_extra_len, $resp_data_type, $resp_status, $resp_total_len, $resp_opaque, $resp_ident_hi, $resp_ident_lo) = unpack(::RES_PKT_FMT, $resp); if ($exists == ::ENTRY_EXISTS) { is($resp_status,"0","Retrieve entry with key $key using binary protocol"); is(substr($resp,::MIN_RECV_BYTES + $resp_extra_len + $resp_key_len, $value_len),$value,"Value for key $key retrieved with binary protocol matches"); } else { is($resp_status,"1","Retrieve non existing entry with key $key using binary protocol"); } } } sub udp_delete_test { my ($protocol, $req_id, $key) = @_; my $req = ""; my $key_len = length($key); if ($protocol == ::IS_ASCII) { $req = "delete $key\r\n"; } elsif ($protocol == ::IS_BINARY) { $req = pack(::REQ_PKT_FMT, ::BIN_REQ_MAGIC, ::CMD_DELETE, $key_len, 0, 0, 0, $key_len, 0, 0, 0); $req .= $key; } my $datagrams = send_udp_request($usock, $req_id, $req); my $resp = construct_udp_message($datagrams); if ($protocol == ::IS_ASCII) { is($resp,"DELETED\r\n","Delete key $key using ASCII protocol"); } elsif ($protocol == ::IS_BINARY) { my ($resp_magic, $resp_op_code, $resp_key_len, $resp_extra_len, $resp_data_type, $resp_status, $resp_total_len, $resp_opaque, $resp_ident_hi, $resp_ident_lo) = unpack(::RES_PKT_FMT, $resp); is($resp_status,"0","Delete key $key using binary protocol"); } } sub udp_incr_decr_test { my ($protocol, $req_id, $key, $val, $optype, $init_val) = @_; my $req = ""; my $key_len = length($key); my $expected_value = 0; my $acmd = "incr"; my $bcmd = ::CMD_INCR; if ($optype eq "incr") { $expected_value = $init_val + $val; } else { $acmd = "decr"; $bcmd = ::CMD_DECR; $expected_value = $init_val - $val; } if ($protocol == ::IS_ASCII) { $req = "$acmd $key $val\r\n"; } elsif ($protocol == ::IS_BINARY) { my $extra = pack(::INCRDECR_PKT_FMT, ($val / 2 ** 32),($val % 2 ** 32), 0, 0, 0); my $extra_len = length($extra); $req = pack(::REQ_PKT_FMT, ::BIN_REQ_MAGIC, $bcmd, $key_len, $extra_len, 0, 0, $key_len + $extra_len, 0, 0, 0); $req .= $extra . $key; } my $datagrams = send_udp_request($usock, $req_id, $req); my $resp = construct_udp_message($datagrams); if ($protocol == ::IS_ASCII) { is($resp,"$expected_value\r\n","perform $acmd math operation on key $key with ASCII protocol"); } elsif ($protocol == ::IS_BINARY) { my ($resp_magic, $resp_op_code, $resp_key_len, $resp_extra_len, $resp_data_type, $resp_status, $resp_total_len, $resp_opaque, $resp_ident_hi, $resp_ident_lo) = unpack(::RES_PKT_FMT, $resp); is($resp_status,"0","perform $acmd math operation on key $key with binary protocol"); my ($resp_hi,$resp_lo) = unpack("NN",substr($resp,::MIN_RECV_BYTES + $resp_extra_len + $resp_key_len, $resp_total_len - $resp_extra_len - $resp_key_len)); is(($resp_hi * 2 ** 32) + $resp_lo,$expected_value,"validate result of binary protocol math operation $acmd . Expected value $expected_value") } } sub construct_udp_message { my $datagrams = shift; my $num_datagram = keys (%$datagrams); my $msg = ""; my $cur_dg =""; my $cur_udp_header =""; for (my $cur_dg_index = 0; $cur_dg_index < $num_datagram; $cur_dg_index++) { $cur_dg = $datagrams->{$cur_dg_index}; isnt($cur_dg,"","missing datagram for segment $cur_dg_index"); $cur_udp_header=substr($cur_dg, 0, 8); $msg .= substr($cur_dg,8); } return $msg; } sub hexify { my $val = shift; $val =~ s/(.)/sprintf("%02x", ord($1))/egs; return $val; } # returns undef on select timeout, or hashref of "seqnum" -> payload (including headers) # verifies that resp_id is equal to id sent in request # ensures consistency in num packets that make up response sub send_udp_request { my ($sock, $reqid, $req) = @_; my $pkt = pack("nnnn", $reqid, 0, 1, 0); # request id (opaque), seq num, #packets, reserved (must be 0) $pkt .= $req; my $fail = sub { my $msg = shift; warn " FAILING send_udp because: $msg\n"; return undef; }; return $fail->("send") unless send($sock, $pkt, 0); my $ret = {}; my $got = 0; # packets got my $numpkts = undef; while (!defined($numpkts) || $got < $numpkts) { my $rin = ''; vec($rin, fileno($sock), 1) = 1; my $rout; return $fail->("timeout after $got packets") unless select($rout = $rin, undef, undef, 1.5); my $res; my $sender = $sock->recv($res, 1500, 0); my ($resid, $seq, $this_numpkts, $resv) = unpack("nnnn", substr($res, 0, 8)); die "Response ID of $resid doesn't match request if of $reqid" unless $resid == $reqid; die "Reserved area not zero" unless $resv == 0; die "num packets changed midstream!" if defined $numpkts && $this_numpkts != $numpkts; $numpkts = $this_numpkts; $ret->{$seq} = $res; $got++; } return $ret; } __END__ $sender = recv($usock, $ans, 1050, 0); __END__ $usock->send ($hispaddr = recv(SOCKET, $rtime, 4, 0)) || die "recv: $!"; ($port, $hisiaddr) = sockaddr_in($hispaddr); $host = gethostbyaddr($hisiaddr, AF_INET); $histime = unpack("N", $rtime) - $SECS_of_70_YEARS ; memcached-1.6.20/t/getset.t0000775000175000017500000000726714340006077012374 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 37991; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached('-m 128'); my $sock = $server->sock; # set foo (and should get it) print $sock "set foo 0 0 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", "fooval"); # add bar (and should get it) print $sock "add bar 0 0 6\r\nbarval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored barval"); mem_get_is($sock, "bar", "barval"); # add foo (but shouldn't get new value) print $sock "add foo 0 0 5\r\nfoov2\r\n"; is(scalar <$sock>, "NOT_STORED\r\n", "not stored"); mem_get_is($sock, "foo", "fooval"); # replace bar (should work) print $sock "replace bar 0 0 6\r\nbarva2\r\n"; is(scalar <$sock>, "STORED\r\n", "replaced barval 2"); # replace notexist (shouldn't work) print $sock "replace notexist 0 0 6\r\nbarva2\r\n"; is(scalar <$sock>, "NOT_STORED\r\n", "didn't replace notexist"); # delete foo. print $sock "delete foo\r\n"; is(scalar <$sock>, "DELETED\r\n", "deleted foo"); # delete foo again. not found this time. print $sock "delete foo\r\n"; is(scalar <$sock>, "NOT_FOUND\r\n", "deleted foo, but not found"); # add moo # print $sock "add moo 0 0 6\r\nmooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored barval"); mem_get_is($sock, "moo", "mooval"); # check-and-set (cas) failure case, try to set value with incorrect cas unique val print $sock "cas moo 0 0 6 0\r\nMOOVAL\r\n"; is(scalar <$sock>, "EXISTS\r\n", "check and set with invalid id"); # test "gets", grab unique ID print $sock "gets moo\r\n"; # VALUE moo 0 6 3084947704 # my @retvals = split(/ /, scalar <$sock>); my $data = scalar <$sock>; # grab data my $dot = scalar <$sock>; # grab dot on line by itself is($retvals[0], "VALUE", "get value using 'gets'"); my $unique_id = $retvals[4]; # clean off \r\n $unique_id =~ s/\r\n$//; ok($unique_id =~ /^\d+$/, "unique ID '$unique_id' is an integer"); # now test that we can store moo with the correct unique id print $sock "cas moo 0 0 6 $unique_id\r\nMOOVAL\r\n"; is(scalar <$sock>, "STORED\r\n"); mem_get_is($sock, "moo", "MOOVAL"); # pipeline is okay print $sock "set foo 0 0 6\r\nfooval\r\ndelete foo\r\nset foo 0 0 6\r\nfooval\r\ndelete foo\r\n"; is(scalar <$sock>, "STORED\r\n", "pipeline set"); is(scalar <$sock>, "DELETED\r\n", "pipeline delete"); is(scalar <$sock>, "STORED\r\n", "pipeline set"); is(scalar <$sock>, "DELETED\r\n", "pipeline delete"); # Test sets up to a large size around 1MB. # Everything up to 1MB - 1k should succeed, everything 1MB +1k should fail. my $len = 1024; while ($len < 1024*1028) { my $val = "B"x$len; if ($len > (1024*1024)) { # Ensure causing a memory overflow doesn't leave stale data. print $sock "set foo_$len 0 0 3\r\nMOO\r\n"; is(scalar <$sock>, "STORED\r\n"); print $sock "set foo_$len 0 0 $len\r\n$val\r\n"; is(scalar <$sock>, "SERVER_ERROR object too large for cache\r\n", "failed to store size $len"); mem_get_is($sock, "foo_$len"); } else { print $sock "set foo_$len 0 0 $len\r\n$val\r\n"; is(scalar <$sock>, "STORED\r\n", "stored size $len"); } $len += 2048; } { # Test large ASCII multigets. print $sock "set foobarbaz 0 0 2\r\nhi\r\n"; is(scalar <$sock>, "STORED\r\n", "base foo stored"); my $len = 1024 * 128; my $klist = ''; my $kcount = 0; for (my $x = 0; $x < $len; $x += 7) { $klist .= "foobarbaz "; $kcount++; } print $sock "get $klist\r\n"; while ($kcount--) { is(scalar <$sock>, "VALUE foobarbaz 0 2\r\n", "foo returned"); is(scalar <$sock>, "hi\r\n", "foo 'hi' returned"); } is(scalar <$sock>, "END\r\n", "foo END seen"); } memcached-1.6.20/t/daemonize.t0000775000175000017500000000134614340006077013044 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 7; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; use File::Temp qw(tempfile); my (undef, $tmpfn) = tempfile(); my $server = new_memcached("-d -P $tmpfn"); my $sock = $server->sock; sleep 0.5; ok(-e $tmpfn, "pid file exists"); ok(-s $tmpfn, "pid file has length"); open (my $fh, $tmpfn) or die; my $readpid = do { local $/; <$fh>; }; chomp $readpid; close ($fh); ok(kill(0, $readpid), "process is still running"); my $stats = mem_stats($sock); is($stats->{pid}, $readpid, "memcached reports same pid as file"); ok($server->new_sock, "opened new socket"); ok(kill(9, $readpid), "sent KILL signal"); sleep 0.5; ok(! $server->new_sock, "failed to open new socket"); memcached-1.6.20/t/dyn-maxbytes.t0000664000175000017500000000505314340006077013511 00000000000000#!/usr/bin/env perl # Test the 'stats items' evictions counters. use strict; use Test::More tests => 309; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached("-m 3 -o modern,slab_automove_window=3"); my $sock = $server->sock; my $value = "B"x66560; my $key = 0; # These aren't set to expire. for ($key = 0; $key < 40; $key++) { print $sock "set key$key 0 0 66560\r\n$value\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key$key"); } my $stats = mem_stats($sock); my $evicted = $stats->{evictions}; isnt($evicted, "0", "check evicted"); # We're past the memory limit. Try adjusting maxbytes upward. $stats = mem_stats($sock, "settings"); my $pre_maxbytes = $stats->{"maxbytes"}; print $sock "cache_memlimit 8\r\n"; is(scalar <$sock>, "OK\r\n", "bumped maxbytes from 3m to 8m"); # Confirm maxbytes updated. $stats = mem_stats($sock, "settings"); isnt($stats->{"maxbytes"}, $pre_maxbytes, "stats settings maxbytes updated"); # Check for total_malloced increasing as new memory is added $stats = mem_stats($sock, "slabs"); my $t_malloc = $stats->{"total_malloced"}; print $sock "set toast 0 0 66560\r\n$value\r\n"; is(scalar <$sock>, "STORED\r\n", "stored toast"); $stats = mem_stats($sock, "slabs"); cmp_ok($stats->{"total_malloced"}, '>', $t_malloc, "stats slabs total_malloced increased"); $stats = mem_stats($sock); my $new_evicted = $stats->{evictions}; cmp_ok($new_evicted, '==', $evicted, "no new evictions"); # Bump up to 16, fill a bit more, then delete everything. print $sock "cache_memlimit 16\r\n"; is(scalar <$sock>, "OK\r\n", "bumped maxbytes from 8m to 16m"); for (;$key < 150; $key++) { print $sock "set key$key 0 0 66560\r\n$value\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key$key"); } # Grab total_malloced after filling everything up. $stats = mem_stats($sock, "slabs"); $t_malloc = $stats->{"total_malloced"}; print $sock "cache_memlimit 8\r\n"; is(scalar <$sock>, "OK\r\n", "bumped maxbytes from 16m to 8m"); # Remove all of the keys, allowing the slab rebalancer to push pages toward # the global page pool. for ($key = 0; $key < 150; $key++) { print $sock "delete key$key\r\n"; like(scalar <$sock>, qr/(DELETED|NOT_FOUND)\r\n/, "deleted key$key"); } # If memory limit is lower, it should free those pages back to the OS. my $reduced = 0; for (my $tries = 0; $tries < 6; $tries++) { sleep 1; $stats = mem_stats($sock, "slabs"); $reduced = $stats->{"total_malloced"} if ($t_malloc > $stats->{"total_malloced"}); last if $reduced; } isnt($reduced, 0, "total_malloced reduced to $reduced"); memcached-1.6.20/t/proxyunits.lua0000664000175000017500000002743514427543277013675 00000000000000function mcp_config_pools(oldss) local srv = mcp.backend mcp.backend_read_timeout(0.5) mcp.backend_connect_timeout(5) -- Single backend for zones to ease testing. -- For purposes of this config the proxy is always "zone 1" (z1) local b1 = srv('b1', '127.0.0.1', 11411) local b2 = srv('b2', '127.0.0.1', 11412) local b3 = srv('b3', '127.0.0.1', 11413) local b1z = {b1} local b2z = {b2} local b3z = {b3} -- convert the backends to pools. -- as per a normal full config see simple.lua or t/startfile.lua local zones = { z1 = mcp.pool(b1z), z2 = mcp.pool(b2z), z3 = mcp.pool(b3z), } return zones end -- WORKER CODE: -- Using a very simple route handler only to allow testing the three -- workarounds in the same configuration file. function prefix_factory(pattern, list, default) local p = pattern local l = list local d = default return function(r) local route = l[string.match(r:key(), p)] if route == nil then return d(r) end return route(r) end end -- just for golfing the code in mcp_config_routes() function toproute_factory(pfx, label) local err = "SERVER_ERROR no " .. label .. " route\r\n" return prefix_factory("^/(%a+)/", pfx, function(r) return err end) end -- Do specialized testing based on the key prefix. function mcp_config_routes(zones) local pfx_get = {} local pfx_set = {} local pfx_touch = {} local pfx_gets = {} local pfx_gat = {} local pfx_gats = {} local pfx_cas = {} local pfx_add = {} local pfx_delete = {} local pfx_incr = {} local pfx_decr = {} local pfx_append = {} local pfx_prepend = {} local pfx_mg = {} local pfx_ms = {} local pfx_md = {} local pfx_ma = {} local basic = function(r) return zones.z1(r) end pfx_get["b"] = basic pfx_set["b"] = basic pfx_touch["b"] = basic pfx_gets["b"] = basic pfx_gat["b"] = basic pfx_gats["b"] = basic pfx_cas["b"] = basic pfx_add["b"] = basic pfx_delete["b"] = basic pfx_incr["b"] = basic pfx_decr["b"] = basic pfx_append["b"] = basic pfx_prepend["b"] = basic pfx_mg["b"] = basic pfx_ms["b"] = basic pfx_md["b"] = basic pfx_ma["b"] = basic pfx_get["errcheck"] = function(r) local res = zones.z1(r) -- expect an error if res:ok() then return "FAIL\r\n" end if res:code() == mcp.MCMC_CODE_ERROR then return "ERROR\r\n" elseif res:code() == mcp.MCMC_CODE_CLIENT_ERROR then return "CLIENT_ERROR\r\n" elseif res:code() == mcp.MCMC_CODE_SERVER_ERROR then return "SERVER_ERROR\r\n" end return "FAIL" end -- show that we fetched the key by generating our own response string. pfx_get["getkey"] = function(r) return "VALUE |" .. r:key() .. " 0 2\r\nts\r\nEND\r\n" end pfx_get["rtrimkey"] = function(r) r:rtrimkey(4) return zones.z1(r) end pfx_get["ltrimkey"] = function(r) r:ltrimkey(10) return zones.z1(r) end pfx_mg["ntokens"] = function(r) return "VA 1 C123 v\r\n" .. r:ntokens() .. "\r\n" end pfx_mg["hasflag"] = function(r) if r:has_flag("c") then return "HD C123\r\n" elseif r:has_flag("O") then return "HD Oabc\r\n" end return "NF\r\n" end -- Input flags: N10 k c R10 -- Output flags: N100 k R100 pfx_mg["flagtoken"] = function(r) -- flag_token on non-existing flags: no effect local Ttoken = r:flag_token("T", "T100") local Otoken = r:flag_token("O", nil) local vtoken = r:flag_token("v", "") if vtoken or Otoken or Ttoken then return "ERROR found non-existing flag." end -- flag_token to replace: N10 -> N100 local found, Ntoken = r:flag_token("N", "N100") if not found or Ntoken ~= "10" then return "ERROR unexpected N token." end -- flag_token with nil 2nd arg: equvalent to fetch r:flag_token("k", nil) if not r:has_flag("k") then return "ERROR unexpected k token." end -- flag_token with self 2nd arg: no effect r:flag_token("c", "c") if not r:has_flag("c") then return "ERROR unexpected c token 1." end -- flag_token with "" 2nd arg: remove r:flag_token("c", "") if r:has_flag("c") then return "ERROR unexpected c token 2." end -- repeated flag_token calls: new value is returned. local _, Rtoken = r:flag_token("R", "R100") if Rtoken ~= '10' then return "ERROR unexpected R token 1." end _, Rtoken = r:flag_token("R", "R100") if Rtoken ~= '100' then return "ERROR unexpected R token 2." end return "HD\r\n" end pfx_ms["request"] = function(r) local key = r:key() local newReq = mcp.request("ms /request/edit 2\r\n", "ab\r\n") return zones.z1(newReq) end pfx_mg["request"] = function(r) local key = r:key() if key == "/request/old" then local newReq = mcp.request("mg /request/new c\r\n") return zones.z1(newReq) else local res = zones.z1(r) local newReq = mcp.request("ms /request/a " .. res:vlen() .. "\r\n", res) return zones.z1(newReq) end end pfx_get["hasflag"] = function(r) if r:has_flag("F") then return "ERROR flag found\r\n" end return "END\r\n" end pfx_ms["token"] = function(r) local key = r:key() if key == "/token/replacement" then r:token(4, "C456") return zones.z1(r) elseif key == "/token/removal" then r:token(4, "") return zones.z1(r) else local token = r:token(2) r:flag_token("P", "P" .. token) return zones.z1(r) end end -- Basic test for routing requests to specific pools. -- Not sure how this could possibly break but testing for completeness. pfx_get["zonetest"] = function(r) local key = r:key() if key == "/zonetest/a" then return zones.z1(r) elseif key == "/zonetest/b" then return zones.z2(r) elseif key == "/zonetest/c" then return zones.z3(r) else return "END\r\n" end end pfx_get["logtest"] = function(r) mcp.log("testing manual log messages") return "END\r\n" end pfx_get["logreqtest"] = function(r) local res = zones.z1(r) mcp.log_req(r, res, "logreqtest") return res end -- tell caller what we got back via a fake response pfx_get["awaitbasic"] = function(r) local vals = {} local rtable = mcp.await(r, { zones.z1, zones.z2, zones.z3 }) for i, res in pairs(rtable) do if res:hit() == true then vals[i] = "hit" elseif res:ok() == true then vals[i] = "ok" else vals[i] = "err" end end local val = table.concat(vals, " ") local vlen = string.len(val) -- convenience functions for creating responses would be nice :) return "VALUE " .. r:key() .. " 0 " .. vlen .. "\r\n" .. val .. "\r\nEND\r\n" end pfx_get["awaitone"] = function(r) local mode = string.sub(r:key(), -1, -1) local num = 0 if mode == "a" then num = 1 elseif mode == "b" then num = 2 end local rtable = mcp.await(r, { zones.z1, zones.z2, zones.z3 }, num) local count = 0 for i, res in pairs(rtable) do count = count + 1 end local vlen = string.len(count) return "VALUE " .. r:key() .. " 0 " .. vlen .. "\r\n" .. count .. "\r\nEND\r\n" end -- should be the same as awaitone pfx_get["awaitgood"] = function(r) local mode = string.sub(r:key(), -1, -1) local num = 0 if mode == "a" then num = 1 elseif mode == "b" then num = 2 end local rtable = mcp.await(r, { zones.z1, zones.z2, zones.z3 }, num, mcp.AWAIT_GOOD) local count = 0 for i, res in pairs(rtable) do count = count + 1 end local vlen = string.len(count) return "VALUE " .. r:key() .. " 0 " .. vlen .. "\r\n" .. count .. "\r\nEND\r\n" end -- not sure if anything else should be checked here? if err or not? pfx_get["awaitany"] = function(r) local rtable = mcp.await(r, { zones.z1, zones.z2, zones.z3 }, 2, mcp.AWAIT_ANY) local count = 0 for i, res in pairs(rtable) do count = count + 1 end local vlen = string.len(count) return "VALUE " .. r:key() .. " 0 " .. vlen .. "\r\n" .. count .. "\r\nEND\r\n" end pfx_get["awaitbg"] = function(r) local rtable = mcp.await(r, { zones.z1, zones.z2, zones.z3 }, 1, mcp.AWAIT_BACKGROUND) local count = 0 for i, res in pairs(rtable) do count = count + 1 end local vlen = string.len(count) return "VALUE " .. r:key() .. " 0 " .. vlen .. "\r\n" .. count .. "\r\nEND\r\n" end pfx_set["awaitlogerr"] = function(r) local rtable = mcp.await_logerrors(r, { zones.z1, zones.z2, zones.z3 }, 1, mcp.AWAIT_FASTGOOD, "write_failed") return rtable[1] end -- testing different styles of building the table argument for mcp.await() pfx_get["awaitfastgood"] = function(r) local all_zones = {} for k, v in pairs(zones) do all_zones[k] = v end local restable = mcp.await(r, all_zones, 2, mcp.AWAIT_FASTGOOD) local final_res = restable[1] local count = 0 for _, res in pairs(restable) do if res:hit() then final_res = res end count = count + 1 end return final_res end pfx_set["awaitfastgood"] = function(r) local all_zones = {} for _, v in pairs(zones) do table.insert(all_zones, v) end local restable = mcp.await(r, all_zones, 2) local count = 0 local good_res = restable[1] for _, res in pairs(restable) do if res:ok() then good_res = res end count = count + 1 end print("Set Response count: " .. count) return good_res end pfx_touch["sanity"] = function(r) local rtable = mcp.await(r, { zones.z1, zones.z2, zones.z3 }) return rtable[3] end mcp.attach(mcp.CMD_GET, toproute_factory(pfx_get, "get")) mcp.attach(mcp.CMD_SET, toproute_factory(pfx_set, "set")) mcp.attach(mcp.CMD_TOUCH, toproute_factory(pfx_touch, "touch")) mcp.attach(mcp.CMD_GETS, toproute_factory(pfx_gets, "gets")) mcp.attach(mcp.CMD_GAT, toproute_factory(pfx_gat, "gat")) mcp.attach(mcp.CMD_GATS, toproute_factory(pfx_gats, "gats")) mcp.attach(mcp.CMD_CAS, toproute_factory(pfx_cas, "cas")) mcp.attach(mcp.CMD_ADD, toproute_factory(pfx_add, "add")) mcp.attach(mcp.CMD_DELETE, toproute_factory(pfx_delete, "delete")) mcp.attach(mcp.CMD_INCR, toproute_factory(pfx_incr, "incr")) mcp.attach(mcp.CMD_DECR, toproute_factory(pfx_decr, "decr")) mcp.attach(mcp.CMD_APPEND, toproute_factory(pfx_append, "append")) mcp.attach(mcp.CMD_PREPEND, toproute_factory(pfx_prepend, "prepend")) mcp.attach(mcp.CMD_MG, toproute_factory(pfx_mg, "mg")) mcp.attach(mcp.CMD_MS, toproute_factory(pfx_ms, "ms")) mcp.attach(mcp.CMD_MD, toproute_factory(pfx_md, "md")) mcp.attach(mcp.CMD_MA, toproute_factory(pfx_ma, "ma")) end memcached-1.6.20/t/slabs_reassign.t0000664000175000017500000000510114340006077014056 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More tests => 131; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; # Enable manual slab reassign, cap at 6 slabs my $server = new_memcached('-o slab_reassign -m 4'); my $stats = mem_stats($server->sock, ' settings'); is($stats->{slab_reassign}, "yes"); my $sock = $server->sock; # Fill a largeish slab until it evicts (honors the -m 6) my $bigdata = 'x' x 70000; # slab 31 for (1 .. 60) { print $sock "set bfoo$_ 0 0 70000\r\n", $bigdata, "\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key"); } # Fill a smaller slab until it evicts my $smalldata = 'y' x 20000; # slab 25 for (1 .. 60) { print $sock "set sfoo$_ 0 0 20000\r\n", $smalldata, "\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key"); } my $items_before = mem_stats($sock, "items"); isnt($items_before->{"items:31:evicted"}, 0, "slab 31 evicted is nonzero"); isnt($items_before->{"items:25:evicted"}, 0, "slab 25 evicted is nonzero"); my $slabs_before = mem_stats($sock, "slabs"); # Invalid argument test print $sock "slabs reassign invalid1 invalid2\r\n"; is(scalar <$sock>, "CLIENT_ERROR bad command line format\r\n"); # Move a large slab to the smaller slab print $sock "slabs reassign 31 25\r\n"; is(scalar <$sock>, "OK\r\n", "slab rebalancer started"); # Still working out how/if to signal the thread. For now, just sleep. sleep 2; # Check that stats counters increased my $slabs_after = mem_stats($sock, "slabs"); $stats = mem_stats($sock); isnt($stats->{slabs_moved}, 0, "slabs moved is nonzero"); # Check that slab stats reflect the change ok($slabs_before->{"31:total_pages"} != $slabs_after->{"31:total_pages"}, "slab 31 pagecount changed"); ok($slabs_before->{"25:total_pages"} != $slabs_after->{"25:total_pages"}, "slab 25 pagecount changed"); # Try to move another slab, see that you can move two in a row print $sock "slabs reassign 31 25\r\n"; like(scalar <$sock>, qr/^OK/, "Cannot re-run against class with empty space"); # Try to move a page backwards. Should complain that source class isn't "safe" # to move from. # TODO: Wait until the above command completes, then try to move it back? # Seems pointless... #print $sock "slabs reassign 25 31\r\n"; #like(scalar <$sock>, qr/^UNSAFE/, "Cannot move an unsafe slab back"); # Try to insert items into both slabs print $sock "set bfoo51 0 0 70000\r\n", $bigdata, "\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key"); print $sock "set sfoo51 0 0 20000\r\n", $smalldata, "\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key"); # Do need to come up with better automated tests for this. memcached-1.6.20/t/64bit.t0000775000175000017500000000216614340006077012022 00000000000000#!/usr/bin/env perl use strict; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; $ENV{T_MEMD_INITIAL_MALLOC} = "4294967328"; # 2**32 + 32 , just over 4GB $ENV{T_MEMD_SLABS_ALLOC} = 0; # don't preallocate slabs my $server = new_memcached("-m 4098 -M"); my $sock = $server->sock; my ($stats, $slabs) = @_; $stats = mem_stats($sock); if ($stats->{'pointer_size'} eq "32") { plan skip_all => 'Skipping 64-bit tests on 32-bit build'; exit 0; } else { plan tests => 6; } is($stats->{'pointer_size'}, 64, "is 64 bit"); is($stats->{'limit_maxbytes'}, "4297064448", "max bytes is 4098 MB"); $slabs = mem_stats($sock, 'slabs'); is($slabs->{'total_malloced'}, "4294967328", "expected (faked) value of total_malloced"); is($slabs->{'active_slabs'}, 0, "no active slabs"); my $hit_limit = 0; for (1..5) { my $size = 400 * 1024; my $data = "a" x $size; print $sock "set big$_ 0 0 $size\r\n$data\r\n"; my $res = <$sock>; $hit_limit = 1 if $res ne "STORED\r\n"; } ok($hit_limit, "hit size limit"); $slabs = mem_stats($sock, 'slabs'); is($slabs->{'active_slabs'}, 1, "1 active slab"); memcached-1.6.20/t/strtol-testing.t0000664000175000017500000000060314340006077014063 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 2; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; print $sock "verbosity invalid\r\n"; is(scalar <$sock>, "CLIENT_ERROR bad command line format\r\n"); print $sock "slabs automove invalid\r\n"; is(scalar <$sock>, "CLIENT_ERROR bad command line format\r\n"); memcached-1.6.20/t/issue_29.t0000664000175000017500000000117314340006077012526 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 4; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; print $sock "set issue29 0 0 0\r\n\r\n"; is (scalar <$sock>, "STORED\r\n", "stored issue29"); my $first_stats = mem_stats($sock, "slabs"); my $first_used = $first_stats->{"1:used_chunks"}; is(1, $first_used, "Used one"); print $sock "set issue29_b 0 0 0\r\n\r\n"; is (scalar <$sock>, "STORED\r\n", "stored issue29_b"); my $second_stats = mem_stats($sock, "slabs"); my $second_used = $second_stats->{"1:used_chunks"}; is(2, $second_used, "Used two") memcached-1.6.20/t/issue_70.t0000664000175000017500000000115014340006077012515 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 4; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; print $sock "set issue70 0 0 0\r\n\r\n"; is (scalar <$sock>, "STORED\r\n", "stored issue70"); print $sock "set issue70 0 0 -1\r\n"; is (scalar <$sock>, "CLIENT_ERROR bad command line format\r\n"); print $sock "set issue70 0 0 4294967295\r\n"; is (scalar <$sock>, "CLIENT_ERROR bad command line format\r\n"); print $sock "set issue70 0 0 2147483647\r\nscoobyscoobydoo"; is (scalar <$sock>, "CLIENT_ERROR bad command line format\r\n"); memcached-1.6.20/t/ascii-auth.t0000664000175000017500000000250514340006077013113 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 9; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; # FIXME: Some tests are forcing UDP to be enabled via MemcachedTest.pm - need # to audit and fix. my $server = new_memcached("-Y $Bin/authfile -U 0"); my $sock = $server->sock; # Test unauthenticated modes print $sock "set foo 0 0 2\r\nhi\r\n"; like(scalar <$sock>, qr/CLIENT_ERROR/, "failed to do a write"); print $sock "get foo\r\n"; like(scalar <$sock>, qr/CLIENT_ERROR/, "failed to do a read"); # Fail to authenticate. print $sock "set foo 0 0 7\r\nfoo bab\r\n"; like(scalar <$sock>, qr/CLIENT_ERROR/, "failed to authenticate"); # Try for real. print $sock "set foo 0 0 7\r\nfoo bar\r\n"; like(scalar <$sock>, qr/STORED/, "authenticated?"); print $sock "set toast 0 0 2\r\nhi\r\n"; like(scalar <$sock>, qr/STORED/, "stored an item that didn't look like user/pass"); mem_get_is($sock, "toast", "hi"); # Create a second socket, try to authenticate against the second token. my $sock2 = $server->new_sock; print $sock2 "set foo 0 0 10\r\nbaaaz quux\r\n"; like(scalar <$sock2>, qr/STORED/, "authenticated a second socket?"); print $sock2 "set toast2 0 0 2\r\nho\r\n"; like(scalar <$sock2>, qr/STORED/, "stored an item that didn't look like user/pass"); mem_get_is($sock2, "toast2", "ho"); # TODO: tests for reloads. memcached-1.6.20/t/noreply.t0000664000175000017500000000230314340006077012550 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 9; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; # Test that commands can take 'noreply' parameter. print $sock "flush_all noreply\r\n"; print $sock "flush_all 0 noreply\r\n"; print $sock "verbosity 0 noreply\r\n"; print $sock "add noreply:foo 0 0 1 noreply\r\n1\r\n"; mem_get_is($sock, "noreply:foo", "1"); print $sock "set noreply:foo 0 0 1 noreply\r\n2\r\n"; mem_get_is($sock, "noreply:foo", "2"); print $sock "replace noreply:foo 0 0 1 noreply\r\n3\r\n"; mem_get_is($sock, "noreply:foo", "3"); print $sock "append noreply:foo 0 0 1 noreply\r\n4\r\n"; mem_get_is($sock, "noreply:foo", "34"); print $sock "prepend noreply:foo 0 0 1 noreply\r\n5\r\n"; my @result = mem_gets($sock, "noreply:foo"); ok($result[1] eq "534"); print $sock "cas noreply:foo 0 0 1 $result[0] noreply\r\n6\r\n"; mem_get_is($sock, "noreply:foo", "6"); print $sock "incr noreply:foo 3 noreply\r\n"; mem_get_is($sock, "noreply:foo", "9"); print $sock "decr noreply:foo 2 noreply\r\n"; mem_get_is($sock, "noreply:foo", "7"); print $sock "delete noreply:foo noreply\r\n"; mem_get_is($sock, "noreply:foo"); memcached-1.6.20/t/restart.t0000664000175000017500000001016114340006077012545 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; # NOTE: Do not use this feature on top of a filesystem, please use a ram disk! # These tests use /tmp/ as some systems do not have or have a weirdly small # /dev/shm. my $mem_path = "/tmp/mc_restart.$$"; # read a invalid metadata file { my $meta_path = "$mem_path.meta"; open(my $f, "> $meta_path") || die("Can't open a metadata file."); eval { new_memcached("-e $mem_path"); }; unlink($meta_path); ok($@, "Died with an empty metadata file"); } my $server = new_memcached("-m 128 -e $mem_path -I 2m"); my $sock = $server->sock; diag "restart basic stats"; { my $stats = mem_stats($server->sock, ' settings'); is($stats->{memory_file}, $mem_path); } diag "Set some values, various sizes."; { my $cur = 2; my $cnt = 0; my $end = 2**20; while ($cur <= $end) { my $val = 'x' x $cur; print $sock "set foo${cnt} 0 0 $cur\r\n$val\r\n"; like(scalar <$sock>, qr/STORED/, "stored $cur size item"); $cur *= 2; $cnt++; } } diag "load enough items to change hash power level"; { my $stats = mem_stats($sock); is($stats->{hash_power_level}, 16, "starting hash level is 16"); my $todo = 2**17; my $good = 1; while ($todo--) { print $sock "set z${todo} 0 0 0\r\n\r\n"; my $res = <$sock>; $good = 0 if ($res !~ m/STORED/); } is($good, 1, "set responses were all STORED"); sleep 3; # sigh. $stats = mem_stats($sock); is($stats->{hash_power_level}, 17, "new hash power level is 17"); # Now delete all these items, so the auto-restore won't cause the hash # table to re-inflate, but the restart code should restore the hash table # to where it was regardless. $todo = 2**17; $good = 1; while ($todo--) { print $sock "delete z${todo}\r\n"; my $res = <$sock>; $good = 0 if ($res !~ m/DELETED/); } is($good, 1, "delete responses were all DELETED"); } diag "Load a couple chunked items"; my $deleted_chunked_item = 0; { my $cur = 768000; my $cnt = 0; my $end = $cur + 1024; while ($cur <= $end) { my $val = 'x' x $cur; print $sock "set chunk${cnt} 0 0 $cur\r\n$val\r\n"; like(scalar <$sock>, qr/STORED/, "stored $cur size item"); $cur += 50; $cnt++; } # delete the last one. $cnt--; $deleted_chunked_item = $cnt; print $sock "delete chunk${cnt}\r\n"; like(scalar <$sock>, qr/DELETED/, "deleted $cnt from large chunked items"); } diag "Data that should expire while stopped."; { print $sock "set low1 0 5 2\r\nbo\r\n"; like(scalar <$sock>, qr/STORED/, "stored low ttl item"); # This one should stay. print $sock "set low2 0 20 2\r\nmo\r\n"; like(scalar <$sock>, qr/STORED/, "stored low ttl item"); } # make sure it's okay to stop with a logger watcher enabled. { my $wsock = $server->new_sock; print $wsock "watch fetchers mutations\n"; my $res = <$wsock>; is($res, "OK\r\n", "watcher enabled"); } $server->graceful_stop(); diag "killed, waiting"; # TODO: add way to wait for server to fully exit.. sleep 10; { $server = new_memcached("-m 128 -e $mem_path -I 2m"); $sock = $server->sock; diag "reconnected"; my $stats = mem_stats($sock); is($stats->{hash_power_level}, 17, "restarted hash power level is 17"); } diag "low TTL item should be gone"; { mem_get_is($sock, 'low1', undef); # but this one should exist. mem_get_is($sock, 'low2', 'mo'); } # initially inserted items. { my $cur = 2; my $cnt = 0; my $end = 1000000; while ($cur < $end) { my $val = 'x' x $cur; mem_get_is($sock, 'foo' . $cnt, $val); $cur *= 2; $cnt++; } } # chunked items. { my $cur = 768000; my $cnt = 0; my $end = $cur + 1024; while ($cur <= $end) { my $val = 'x' x $cur; if ($cnt != $deleted_chunked_item) { mem_get_is($sock, 'chunk' . $cnt, $val); } $cur += 50; $cnt++; } } done_testing(); END { unlink $mem_path if $mem_path; } memcached-1.6.20/t/flush-all.t0000775000175000017500000000617514340006077012765 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 27; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $expire; print $sock "set foo 0 0 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", "fooval"); print $sock "flush_all\r\n"; is(scalar <$sock>, "OK\r\n", "did flush_all"); mem_get_is($sock, "foo", undef); # Test flush_all with zero delay. print $sock "set foo 0 0 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", "fooval"); print $sock "flush_all 0\r\n"; is(scalar <$sock>, "OK\r\n", "did flush_all"); mem_get_is($sock, "foo", undef); # check that flush_all doesn't blow away items that immediately get set print $sock "set foo 0 0 3\r\nnew\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo = 'new'"); mem_get_is($sock, "foo", 'new'); # and the other form, specifying a flush_all time... my $expire = time() + 2; print $sock "flush_all $expire\r\n"; is(scalar <$sock>, "OK\r\n", "did flush_all in future"); print $sock "set foo 0 0 4\r\n1234\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo = '1234'"); mem_get_is($sock, "foo", '1234'); sleep(5); mem_get_is($sock, "foo", undef); print $sock "set foo 0 0 5\r\n12345\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo = '12345'"); mem_get_is($sock, "foo", '12345'); print $sock "flush_all 86400\r\n"; is(scalar <$sock>, "OK\r\n", "did flush_all for far future"); # Check foo still exists. mem_get_is($sock, "foo", '12345'); print $sock "set foo2 0 0 5\r\n54321\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo2 = '54321'"); mem_get_is($sock, "foo", '12345'); mem_get_is($sock, "foo2", '54321'); # Test invalid argument print $sock "flush_all invalid\r\n"; is(scalar <$sock>, "CLIENT_ERROR invalid exptime argument\r\n"); # Test -F option which disables flush_all $server = new_memcached('-F'); $sock = $server->sock; print $sock "set foo 0 0 7\r\nfooval2\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", "fooval2"); print $sock "flush_all\r\n"; is(scalar <$sock>, "CLIENT_ERROR flush_all not allowed\r\n", "flush_all was not allowed"); mem_get_is($sock, "foo", "fooval2"); # Test that disabling CAS makes flush_all less accurate. # Due to lock ordering issues we can no longer evict items newer than # oldest_live, so we rely on the CAS counter for an exact cliff. So disabling # CAS now means all items set in the same second will fail to set. $server = new_memcached('-C'); $sock = $server->sock; my $failed_nocas = 0; # Running this 100,000 times failed the test a handful of times. 50 tries # should be enough. for (1..50) { print $sock "flush_all 0\r\n"; my $foo = scalar <$sock>; print $sock "set foo 0 0 3\r\nnew\r\n"; $foo = scalar <$sock>; print $sock "get foo\r\n"; my $line = scalar <$sock>; if ($line =~ /^VALUE/) { $line = scalar <$sock>; $line = scalar <$sock>; print STDERR "Succeeded!!!\n"; next; } elsif ($line =~ /^END/) { $failed_nocas++; last; } } is($failed_nocas, 1, "failed to set value after flush with no CAS at least once"); memcached-1.6.20/t/issue_42.t0000664000175000017500000000140514340006077012517 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 11; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached("-o no_modern"); my $sock = $server->sock; my $value = "B"x10; my $key = 0; my $key_count = 10; for ($key = 0; $key < $key_count; $key++) { print $sock "set key$key 0 0 10\r\n$value\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key$key"); } my $stats = mem_stats($sock, "slabs"); my $stats2 = mem_stats($sock, "items"); my $req = $stats2->{"items:1:mem_requested"}; my $top = $stats->{"1:chunk_size"} * $key_count; # unreasonable for the result to be < 500 bytes (min item header is 48), but # should be less than the maximum potential number. ok ($req > 500 && $req < $top, "Check allocated size: $req $top"); memcached-1.6.20/t/client_crt.pem0000664000175000017500000001052414301776131013532 00000000000000Certificate: Data: Version: 3 (0x2) Serial Number: 78:f7:9b:75:a7:9d:83:12:a5:c7:a0:b6:af:87:da:c3:d9:32:c2:d7 Signature Algorithm: sha256WithRSAEncryption Issuer: CN = Test Root Certificate Authority, ST = CA, C = US, emailAddress = root@test.com, O = Test, OU = Test Department Validity Not Before: Oct 27 03:10:04 2020 GMT Not After : Jun 28 03:10:04 2520 GMT Subject: C = US, ST = CA, O = Test Client, OU = Subunit of Test Organization, CN = client.test.com, emailAddress = root@client.test.com Subject Public Key Info: Public Key Algorithm: rsaEncryption RSA Public-Key: (2048 bit) Modulus: 00:d5:66:c9:c9:ef:64:ad:0f:c7:fe:74:fb:e4:75: b3:76:60:7f:bb:5e:38:e9:25:e4:70:8c:99:63:ad: 76:26:b8:06:65:f5:0e:b6:6f:22:66:b7:4b:7a:8c: 4f:3a:fb:0e:ac:c1:0e:6e:76:db:b5:95:83:d4:a2: 86:eb:78:63:c5:d3:47:97:d9:6e:0f:39:ee:cd:51: b6:af:cd:01:2c:a0:c0:bb:58:eb:23:6a:aa:09:e3: 69:31:2e:83:49:88:42:71:7d:25:aa:f1:63:5e:93: a5:44:19:47:b2:3b:1c:7a:f1:f2:24:75:51:6f:13: 7e:9a:24:2c:42:e3:23:31:b6:dd:fa:50:36:92:ef: c3:c2:40:fe:45:b9:80:79:d9:64:62:02:f4:de:8c: 58:fa:74:b9:fa:65:08:8f:46:79:a8:c6:69:df:88: ee:18:d8:4d:90:a6:30:4f:3d:b7:78:56:1e:a7:24: 20:48:3b:e5:ab:e7:8e:41:6e:9f:f1:3d:34:f6:1a: a3:ef:ad:3f:87:00:b9:88:0f:bf:ce:c4:4e:4a:fc: 1e:90:43:40:b1:df:86:cc:dd:1e:35:4f:95:9c:28: 65:e4:5e:ba:0d:0b:3f:c7:5f:28:b3:4a:be:d2:d7: 4f:38:da:f0:3d:68:3c:40:e7:db:fd:7a:79:89:4c: 43:d1 Exponent: 65537 (0x10001) X509v3 extensions: X509v3 Subject Alternative Name: DNS:client.test.com, DNS:alt.client.test.com Signature Algorithm: sha256WithRSAEncryption 47:6a:90:28:93:f3:31:ad:8d:70:59:1b:1d:c2:9a:63:b1:40: 64:39:a1:5d:22:25:c1:45:e0:0b:98:82:47:c9:0d:31:44:d7: 6a:cc:38:8b:ee:67:f4:43:7a:63:7e:b7:84:64:23:de:98:eb: a3:5f:5a:ca:da:bc:37:16:76:dc:55:5b:eb:71:ef:f5:f9:f9: db:77:34:1c:8e:b5:fe:9a:00:9d:bf:9f:5a:1a:51:68:54:47: ef:0c:fb:cd:7f:08:81:01:bd:6e:6a:05:27:1d:66:38:75:7b: 69:66:bf:8d:e7:e1:15:a6:5b:2d:1f:7a:c3:8a:af:14:88:da: ab:6f:87:8f:df:cd:b6:82:f0:5e:f4:aa:de:36:ab:a0:de:eb: dd:8b:dc:e7:58:ec:48:8a:27:3f:a2:97:69:aa:63:9e:74:5b: 33:2d:1e:0a:17:02:7f:e3:97:10:75:3e:7d:77:48:a6:72:fb: 5d:d7:68:78:1e:5c:ca:5a:8d:6f:48:f0:ea:92:e3:25:85:9f: 7b:ec:fa:93:8e:ff:ef:bc:70:bd:77:5b:8e:38:cb:df:4e:5e: 35:51:1b:ee:58:1d:cc:cb:bb:e0:85:1f:b6:84:c3:da:c0:1e: 9b:71:88:02:c3:cc:8c:a1:77:0c:bb:e2:ea:05:d5:30:e6:9c: 2d:d6:d2:e5 -----BEGIN CERTIFICATE----- MIID5jCCAs6gAwIBAgIUePebdaedgxKlx6C2r4faw9kywtcwDQYJKoZIhvcNAQEL BQAwgYsxKDAmBgNVBAMMH1Rlc3QgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkx CzAJBgNVBAgMAkNBMQswCQYDVQQGEwJVUzEcMBoGCSqGSIb3DQEJARYNcm9vdEB0 ZXN0LmNvbTENMAsGA1UECgwEVGVzdDEYMBYGA1UECwwPVGVzdCBEZXBhcnRtZW50 MCAXDTIwMTAyNzAzMTAwNFoYDzI1MjAwNjI4MDMxMDA0WjCBljELMAkGA1UEBhMC VVMxCzAJBgNVBAgMAkNBMRQwEgYDVQQKDAtUZXN0IENsaWVudDElMCMGA1UECwwc U3VidW5pdCBvZiBUZXN0IE9yZ2FuaXphdGlvbjEYMBYGA1UEAwwPY2xpZW50LnRl c3QuY29tMSMwIQYJKoZIhvcNAQkBFhRyb290QGNsaWVudC50ZXN0LmNvbTCCASIw DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANVmycnvZK0Px/50++R1s3Zgf7te OOkl5HCMmWOtdia4BmX1DrZvIma3S3qMTzr7DqzBDm5227WVg9Sihut4Y8XTR5fZ bg857s1Rtq/NASygwLtY6yNqqgnjaTEug0mIQnF9JarxY16TpUQZR7I7HHrx8iR1 UW8TfpokLELjIzG23fpQNpLvw8JA/kW5gHnZZGIC9N6MWPp0ufplCI9GeajGad+I 7hjYTZCmME89t3hWHqckIEg75avnjkFun/E9NPYao++tP4cAuYgPv87ETkr8HpBD QLHfhszdHjVPlZwoZeReug0LP8dfKLNKvtLXTzja8D1oPEDn2/16eYlMQ9ECAwEA AaMzMDEwLwYDVR0RBCgwJoIPY2xpZW50LnRlc3QuY29tghNhbHQuY2xpZW50LnRl c3QuY29tMA0GCSqGSIb3DQEBCwUAA4IBAQBHapAok/MxrY1wWRsdwppjsUBkOaFd IiXBReALmIJHyQ0xRNdqzDiL7mf0Q3pjfreEZCPemOujX1rK2rw3FnbcVVvrce/1 +fnbdzQcjrX+mgCdv59aGlFoVEfvDPvNfwiBAb1uagUnHWY4dXtpZr+N5+EVplst H3rDiq8UiNqrb4eP3822gvBe9KreNqug3uvdi9znWOxIiic/opdpqmOedFszLR4K FwJ/45cQdT59d0imcvtd12h4HlzKWo1vSPDqkuMlhZ977PqTjv/vvHC9d1uOOMvf Tl41URvuWB3My7vghR+2hMPawB6bcYgCw8yMoXcMu+LqBdUw5pwt1tLl -----END CERTIFICATE----- memcached-1.6.20/t/lru.t0000775000175000017500000000315614340006077011674 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 149; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; # assuming max slab is 1M and default mem is 64M my $server = new_memcached('-o no_modern'); my $sock = $server->sock; # create a big value for the largest slab my $max = 1024 * 1024; my $big = 'x' x (1024 * 1024 - 250); ok(length($big) > 512 * 1024); ok(length($big) < 1024 * 1024); # test that an even bigger value is rejected while we're here my $too_big = $big . $big . $big; my $len = length($too_big); print $sock "set too_big 0 0 $len\r\n$too_big\r\n"; is(scalar <$sock>, "SERVER_ERROR object too large for cache\r\n", "too_big not stored"); # set the big value my $len = length($big); print $sock "set big 0 0 $len\r\n$big\r\n"; is(scalar <$sock>, "STORED\r\n", "stored big"); mem_get_is($sock, "big", $big); # no evictions yet my $stats = mem_stats($sock); is($stats->{"evictions"}, "0", "no evictions to start"); # set many big items, enough to get evictions for (my $i = 0; $i < 100; $i++) { print $sock "set item_$i 0 0 $len\r\n$big\r\n"; is(scalar <$sock>, "STORED\r\n", "stored item_$i"); } # some evictions should have happened my $stats = mem_stats($sock); my $evictions = int($stats->{"evictions"}); ok($evictions == 37, "some evictions happened"); # the first big value should be gone mem_get_is($sock, "big", undef); # the earliest items should be gone too for (my $i = 0; $i < $evictions - 1; $i++) { mem_get_is($sock, "item_$i", undef); } # check that the non-evicted are the right ones for (my $i = $evictions - 1; $i < $evictions + 4; $i++) { mem_get_is($sock, "item_$i", $big); } memcached-1.6.20/t/proxyinternal.t0000664000175000017500000000652714427543277014030 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use Carp qw(croak); use MemcachedTest; use IO::Socket qw(AF_INET SOCK_STREAM); use IO::Select; if (!supports_proxy()) { plan skip_all => 'proxy not enabled'; exit 0; } # Don't want to write two distinct set of tests, and extstore is a default. if (!supports_extstore()) { plan skip_all => 'extstore not enabled'; exit 0; } my $ext_path = "/tmp/proxyinternal.$$"; # Set up some server sockets. sub mock_server { my $port = shift; my $srv = IO::Socket->new( Domain => AF_INET, Type => SOCK_STREAM, Proto => 'tcp', LocalHost => '127.0.0.1', LocalPort => $port, ReusePort => 1, Listen => 5) || die "IO::Socket: $@"; return $srv; } # Put a version command down the pipe to ensure the socket is clear. # client version commands skip the proxy code sub check_version { my $ps = shift; print $ps "version\r\n"; like(<$ps>, qr/VERSION /, "version received"); } my @mocksrvs = (); #diag "making mock servers"; for my $port (11611, 11612, 11613) { my $srv = mock_server($port); ok(defined $srv, "mock server created"); push(@mocksrvs, $srv); } my $p_srv = new_memcached("-o proxy_config=./t/proxyinternal.lua,ext_item_size=500,ext_item_age=1,ext_path=$ext_path:64m,ext_max_sleep=100000"); my $ps = $p_srv->sock; $ps->autoflush(1); # set up server backend sockets. # uncomment when needed. currently they get thrown out so this can hang. #my @mbe = (); #diag "accepting mock backends"; #for my $msrv (@mocksrvs) { # my $be = $msrv->accept(); # $be->autoflush(1); # ok(defined $be, "mock backend created"); # push(@mbe, $be); #} #diag "validating backends"; #for my $be (@mbe) { # like(<$be>, qr/version/, "received version command"); # print $be "VERSION 1.0.0-mock\r\n"; #} #diag "object too large" { my $data = 'x' x 2000000; print $ps "set /b/toolarge 0 0 2000000\r\n$data\r\n"; is(scalar <$ps>, "SERVER_ERROR object too large for cache\r\n", "set too large"); print $ps "ms /b/toolarge 2000000 T30\r\n$data\r\n"; is(scalar <$ps>, "SERVER_ERROR object too large for cache\r\n", "ms too large"); } #diag "basic tests" { print $ps "set /b/foo 0 0 2\r\nhi\r\n"; is(scalar <$ps>, "STORED\r\n", "int set"); print $ps "get /b/foo\r\n"; is(scalar <$ps>, "VALUE /b/foo 0 2\r\n", "get response"); is(scalar <$ps>, "hi\r\n", "get value"); is(scalar <$ps>, "END\r\n", "get END"); } #diag "fetch from extstore" { my $data = 'x' x 1000; print $ps "set /b/ext 0 0 1000\r\n$data\r\n"; is(scalar <$ps>, "STORED\r\n", "int set for extstore"); sleep 3; # TODO: import wait_for_ext print $ps "get /b/ext\r\n"; is(scalar <$ps>, "VALUE /b/ext 0 1000\r\n", "get response from extstore"); is(scalar <$ps>, "$data\r\n", "got data from extstore"); is(scalar <$ps>, "END\r\n", "get END"); } #diag "flood memory" { # ensure we don't have a basic reference counter leak my $data = 'x' x 500000; for (1 .. 200) { print $ps "set /b/$_ 0 0 500000\r\n$data\r\n"; is(scalar <$ps>, "STORED\r\n", "flood set"); } for (1 .. 200) { print $ps "ms /b/$_ 500000 T30\r\n$data\r\n"; is(scalar <$ps>, "HD\r\n", "flood ms"); } } done_testing(); END { unlink $ext_path if $ext_path; } memcached-1.6.20/t/watcher.t0000775000175000017500000002223314427543277012542 00000000000000#!/usr/bin/env perl # Networked logging tests. use strict; use warnings; use Socket qw/SO_RCVBUF/; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; plan tests => 43; my $server = new_memcached('-m 60 -o watcher_logbuf_size=8'); my $client = $server->sock; my $watcher = $server->new_sock; # This doesn't return anything. print $watcher "watch\n"; my $res = <$watcher>; is($res, "OK\r\n", "watcher enabled"); print $client "get foo\n"; $res = <$client>; is($res, "END\r\n", "basic get works"); my $spacer = "X"x180; # This is a flaky test... depends on buffer sizes. Could either have memc # shrink the watcher buffer, or loop this and keep doubling until we get some # skipped values. for (1 .. 80000) { print $client "get foo$_$spacer\n"; $res = <$client>; } # Let the logger thread catch up before we start reading. sleep 1; my $do_fetch = 0; #print STDERR "RESULT: $res\n"; while (my $log = <$watcher>) { # The "skipped" line won't actually print until some space frees up in the # buffer, so we need to occasionally cause new lines to generate. if (($do_fetch++ % 100) == 0) { print $client "get foo\n"; $res = <$client>; } next unless $log =~ m/skipped/; like($log, qr/skipped=/, "skipped some lines"); # This should unjam more of the text. print $client "get foob\n"; $res = <$client>; last; } $res = <$watcher>; like($res, qr/ts=\d+\.\d+\ gid=\d+ type=item_get/, "saw a real log line after a skip"); # testing the longest uri encoded key length { my $new_watcher = $server->new_sock; print $new_watcher "watch mutations\n"; my $watch_res = <$new_watcher>; my $key = ""; my $max_keylen = 250; for (1 .. $max_keylen) { $key .= "#"; } print $client "set $key 0 0 9\r\nmemcached\r\n"; $res = <$client>; is ($res, "STORED\r\n", "stored the long key"); if ($res eq "STORED\r\n") { $watch_res = <$new_watcher>; my $max_uri_keylen = $max_keylen * 3 + length("key="); my @tab = split(/\s+/, $watch_res); is (length($tab[3]), $max_uri_keylen, "got the correct uri encoded key length");; } } # test connection events { # start a dedicated server so that connection close events from previous # tests don't leak into this one due to races. my $conn_server = new_memcached('-m 60 -o watcher_logbuf_size=8'); my $conn_watcher = $conn_server->new_sock; sleep 1; print $conn_watcher "watch connevents\n"; $res = <$conn_watcher>; is($res, "OK\r\n", 'connevents watcher enabled'); # normal close my $conn_client = $conn_server->new_sock; print $conn_client "version\r\n"; $res = <$conn_client>; print $conn_client "quit\r\n"; $res = <$conn_watcher>; like($res, qr/ts=\d+\.\d+\ gid=\d+ type=conn_new .+ transport=(local|tcp)/, 'logged new connection'); $res = <$conn_watcher>; like($res, qr/ts=\d+\.\d+\ gid=\d+ type=conn_close .+ transport=(local|tcp) reason=normal/, 'logged closed connection due to client disconnect'); # error close $conn_client = $conn_server->new_sock; print $conn_client "GET / HTTP/1.1\r\n"; $res = <$conn_watcher>; like($res, qr/ts=\d+\.\d+\ gid=\d+ type=conn_new .+ transport=(local|tcp)/, 'logged new connection'); $res = <$conn_watcher>; like($res, qr/ts=\d+\.\d+\ gid=\d+ type=conn_close .+ transport=(local|tcp) reason=error/, 'logged closed connection due to client protocol error'); } # test combined logs # fill to evictions, then enable watcher, set again, and look for both lines { my $value = "B"x11000; my $keycount = 8000; for (1 .. $keycount) { print $client "set n,foo$_ 0 0 11000 noreply\r\n$value\r\n"; } # wait for all of the writes to go through. print $client "version\r\n"; $res = <$client>; my $mwatcher = $server->new_sock; print $mwatcher "watch mutations evictions\n"; $res = <$mwatcher>; is($res, "OK\r\n", "new watcher enabled"); my $watcher2 = $server->new_sock; print $watcher2 "watch evictions\n"; $res = <$watcher2>; is($res, "OK\r\n", "evictions watcher enabled"); print $client "set bfoo 0 0 11000 noreply\r\n$value\r\n"; my $found_log = 0; my $found_ev = 0; while (my $log = <$mwatcher>) { $found_log = 1 if ($log =~ m/type=item_store/); $found_ev = 1 if ($log =~ m/type=eviction/); last if ($found_log && $found_ev); } is($found_log, 1, "found rawcmd log entry"); is($found_ev, 1, "found eviction log entry"); } # test cas command logs # TODO: need to expose active watchers in stats, so we can monitor for when # the previous ones are fully disconnected. They might be swallowing the logs # before we get them. Since I can't reproduce this locally and travis takes 30 # minutes to fail I can't instrument this. SKIP: { skip "Mysteriously fails on travis CI.", 1; $watcher = $server->new_sock; print $watcher "watch mutations\n"; $res = <$watcher>; is($res, "OK\r\n", "mutations watcher enabled"); # There's a bit of a startup race where some workers may not have the log # enabled yet, so we try a little harder to get the log line in there. sleep 1; for (1 .. 20) { print $client "cas cas_watch_key 0 0 5 0\r\nvalue\r\n"; $res = <$client>; } my $tries = 30; my $found_cas = 0; while (my $log = <$watcher>) { $found_cas = 1 if ($log =~ m/cmd=cas/ && $log =~ m/cas_watch_key/); last if ($tries-- == 0 || $found_cas); } is($found_cas, 1, "correctly logged cas command"); } # test get/set value sizes { my $watcher = $server->new_sock; print $watcher "watch fetchers mutations\n"; is(<$watcher>, "OK\r\n", "fetchers and mutations watcher enabled"); print $client "set vfoo 0 0 4\r\nvbar\r\n"; is(<$client>, "STORED\r\n", "stored the key"); print $client "get vfoo\r\n"; is(<$client>, "VALUE vfoo 0 4\r\n", "read the key header"); is(<$client>, "vbar\r\n", "read the key value"); is(<$client>, "END\r\n", "read the value trailer"); sleep 1; like(<$watcher>, qr/ts=\d+\.\d+\ gid=\d+ type=item_get key=vfoo .+ size=0/, "logged initial item fetch"); like(<$watcher>, qr/ts=\d+\.\d+\ gid=\d+ type=item_store key=vfoo .+ size=4/, "logged item store with correct size"); like(<$watcher>, qr/ts=\d+\.\d+\ gid=\d+ type=item_get key=vfoo .+ size=4/, "logged item get with correct size"); } # test watcher stats { my $stats_server = new_memcached('-m 60 -o watcher_logbuf_size=8'); my $stats_client = $stats_server->sock; my $stats; my $watcher1 = $stats_server->new_sock; print $watcher1 "watch fetchers\n"; $res = <$watcher1>; is($res, "OK\r\n", 'fetchers watcher enabled'); sleep 1; $stats = mem_stats($stats_client); is($stats->{log_watchers}, 1, 'tracked new fetchers watcher'); my $watcher2 = $stats_server->new_sock; print $watcher2 "watch fetchers\n"; $res = <$watcher2>; is($res, "OK\r\n", 'mutations watcher enabled'); sleep 1; $stats = mem_stats($stats_client); is($stats->{log_watchers}, 2, 'tracked new mutations watcher'); $watcher1->close(); $watcher2->close(); sleep 1; $stats = mem_stats($stats_client); is($stats->{log_watchers}, 0, 'untracked all watchers'); } # test no_watch option { my $nowatch_server = new_memcached('-W'); my $watchsock = $nowatch_server->new_sock; print $watchsock "watch mutations\n"; my $watchresult = <$watchsock>; is($watchresult, "CLIENT_ERROR watch commands not allowed\r\n", "attempted watch gave client error with no_watch option set"); } # test delete/meta-delete with value sizes { my $watcher = $server->new_sock; print $watcher "watch deletions\n"; is(<$watcher>, "OK\r\n", "deletions watcher enabled"); print $client "set vfoo 0 0 4\r\nvbar\r\n"; is(<$client>, "STORED\r\n", "stored the key"); # wouldn't be logged to watcher print $client "md non-existing-key\r\n"; is(<$client>, "NF\r\n", "non-existing key can't be deleted"); print $client "delete vfoo\r\n"; is(<$client>, "DELETED\r\n", "key was deleted"); like(<$watcher>, qr/ts=\d+\.\d+\ gid=\d+ type=deleted key=vfoo cmd=delete .+ size=4/, "delete command logged with correct size"); print $client "set vfoo 0 0 4\r\nvbar\r\n"; is(<$client>, "STORED\r\n", "stored the key"); print $client "md vfoo\r\n"; is(<$client>, "HD\r\n", "key was deleted"); like(<$watcher>, qr/ts=\d+\.\d+\ gid=\d+ type=deleted key=vfoo cmd=md .+ size=4/, "meta-delete command logged with correct size"); print $client "set vfoo 0 0 4\r\nvbar\r\n"; is(<$client>, "STORED\r\n", "stored the key"); # shouldn't result in log line print $client "md vfoo I\r\n"; is(<$client>, "HD\r\n", "key was marked stale"); print $client "mg vfoo\r\n"; is(<$client>, "HD X W\r\n", "mg shows key is stale and won recache"); # now do a delete and it will show up in the log, explicitly use delete instead of md to check the cmd= pair in log print $client "delete vfoo\r\n"; is(<$client>, "DELETED\r\n", "key was deleted"); like(<$watcher>, qr/ts=\d+\.\d+\ gid=\d+ type=deleted key=vfoo cmd=delete .+ size=4/, "delete command logged with correct size"); } memcached-1.6.20/t/item_size_max.t0000664000175000017500000000236614340006077013726 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 7; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $stats = mem_stats($sock, ' settings'); # Ensure default still works. is($stats->{item_size_max}, 1024 * 1024); $server->stop(); # Should die. eval { $server = new_memcached('-I 1000'); }; ok($@ && $@ =~ m/^Failed/, "Shouldn't start with < 1k item max"); eval { $server = new_memcached('-I 256m'); }; ok($@ && $@ =~ m/^Failed/, "Shouldn't start with > 128m item max"); # Minimum. $server = new_memcached('-I 1024 -o slab_chunk_max=1024'); my $stats = mem_stats($server->sock, ' settings'); is($stats->{item_size_max}, 1024); $server->stop(); # Reasonable but unreasonable. $server = new_memcached('-I 2097152'); my $stats = mem_stats($server->sock, ' settings'); is($stats->{item_size_max}, 2097152); $server->stop(); # Suffix kilobytes. $server = new_memcached('-I 512k -o slab_chunk_max=16384'); my $stats = mem_stats($server->sock, ' settings'); is($stats->{item_size_max}, 524288); $server->stop(); # Suffix megabytes. $server = new_memcached('-m 256 -I 32m'); my $stats = mem_stats($server->sock, ' settings'); is($stats->{item_size_max}, 33554432); $server->stop(); memcached-1.6.20/t/whitespace.t0000775000175000017500000000323114340006077013220 00000000000000#!/usr/bin/env perl use strict; use FindBin qw($Bin); our @files; BEGIN { chdir "$Bin/.." or die; unless (-d "$Bin/../.git") { use Test::More; plan skip_all => "Skipping test because this does not appear to be a memcached git working directory"; exit 0; } my @exempted = qw(Makefile.am ChangeLog doc/Makefile.am README README.md compile_commands.json md5.c md5.h); push(@exempted, glob("doc/*.xml")); push(@exempted, glob("doc/*.full")); push(@exempted, glob("doc/xml2rfc/*.xsl")); push(@exempted, glob("doc/xml2rfc/*.dtd")); push(@exempted, glob("m4/*backport*m4")); push(@exempted, glob("*.orig")); push(@exempted, glob(".*.swp")); push(@exempted, glob("queue.h")); my %exempted_hash = map { $_ => 1 } @exempted; my @stuff = split /\0/, `git ls-files -z -c -m -o --exclude-standard`; @files = grep { ! $exempted_hash{$_} && $_ !~ m/^vendor/ } @stuff; # We won't find any files if git isn't installed. If git isn't # installed, they're probably not doing any useful development, or # at the very least am will clean up whitespace when we receive # their patch. unless (@files) { use Test::More; plan skip_all => "Skipping tests probably because you don't have git."; exit 0; } } use Test::More tests => scalar(@files); foreach my $f (@files) { open(my $fh, $f) or die "Cannot open file $f: $!"; my $before = do { local $/; <$fh>; }; close ($fh); my $after = $before; $after =~ s/\t/ /g; $after =~ s/ +$//mg; $after .= "\n" unless $after =~ /\n$/; ok ($after eq $before, "$f (see devtools/clean-whitespace.pl)"); } memcached-1.6.20/t/unixsocket.t0000775000175000017500000000135214340006077013262 00000000000000#!/usr/bin/env perl use strict; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $filename = "/tmp/memcachetest$$"; if (supports_unix_socket()) { plan tests => 3; my $server = new_memcached("-s $filename"); my $sock = $server->sock; ok(-S $filename, "creating unix domain socket $filename"); # set foo (and should get it) print $sock "set foo 0 0 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is($sock, "foo", "fooval"); unlink($filename); ## Just some basic stuff for now... } else { plan tests => 1; eval { my $server = new_memcached("-s $filename"); }; ok($@, "Died connecting to unsupported unix socket."); } memcached-1.6.20/t/binary.t0000775000175000017500000006134414400442673012364 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached("-o no_modern"); ok($server, "started the server"); # Based almost 100% off testClient.py which is: # Copyright (c) 2007 Dustin Sallings # Command constants use constant CMD_GET => 0x00; use constant CMD_SET => 0x01; use constant CMD_ADD => 0x02; use constant CMD_REPLACE => 0x03; use constant CMD_DELETE => 0x04; use constant CMD_INCR => 0x05; use constant CMD_DECR => 0x06; use constant CMD_QUIT => 0x07; use constant CMD_FLUSH => 0x08; use constant CMD_GETQ => 0x09; use constant CMD_NOOP => 0x0A; use constant CMD_VERSION => 0x0B; use constant CMD_GETK => 0x0C; use constant CMD_GETKQ => 0x0D; use constant CMD_APPEND => 0x0E; use constant CMD_PREPEND => 0x0F; use constant CMD_STAT => 0x10; use constant CMD_SETQ => 0x11; use constant CMD_ADDQ => 0x12; use constant CMD_REPLACEQ => 0x13; use constant CMD_DELETEQ => 0x14; use constant CMD_INCREMENTQ => 0x15; use constant CMD_DECREMENTQ => 0x16; use constant CMD_QUITQ => 0x17; use constant CMD_FLUSHQ => 0x18; use constant CMD_APPENDQ => 0x19; use constant CMD_PREPENDQ => 0x1A; use constant CMD_TOUCH => 0x1C; use constant CMD_GAT => 0x1D; use constant CMD_GATQ => 0x1E; use constant CMD_GATK => 0x23; use constant CMD_GATKQ => 0x24; # REQ and RES formats are divided even though they currently share # the same format, since they _could_ differ in the future. use constant REQ_PKT_FMT => "CCnCCnNNNN"; use constant RES_PKT_FMT => "CCnCCnNNNN"; use constant INCRDECR_PKT_FMT => "NNNNN"; use constant MIN_RECV_BYTES => length(pack(RES_PKT_FMT)); use constant REQ_MAGIC => 0x80; use constant RES_MAGIC => 0x81; my $mc = MC::Client->new; # Let's turn on detail stats for all this stuff $mc->stats('detail on'); my $check = sub { my ($key, $orig_flags, $orig_val) = @_; my ($flags, $val, $cas) = $mc->get($key); is($flags, $orig_flags, "Flags is set properly"); ok($val eq $orig_val || $val == $orig_val, $val . " = " . $orig_val); }; my $set = sub { my ($key, $exp, $orig_flags, $orig_value) = @_; $mc->set($key, $orig_value, $orig_flags, $exp); $check->($key, $orig_flags, $orig_value); }; my $empty = sub { my $key = shift; my $rv =()= eval { $mc->get($key) }; is($rv, 0, "Didn't get a result from get"); ok($@->not_found, "We got a not found error when we expected one"); }; my $delete = sub { my ($key, $when) = @_; $mc->delete($key, $when); $empty->($key); }; # diag "Test Version"; my $v = $mc->version; ok(defined $v && length($v), "Proper version: $v"); # Bug 71 { my %stats1 = $mc->stats(''); $mc->flush; my %stats2 = $mc->stats(''); is($stats2{'cmd_flush'}, $stats1{'cmd_flush'} + 1, "Stats not updated on a binary flush"); } # diag "Flushing..."; $mc->flush; # diag "Noop"; $mc->noop; # diag "Simple set/get"; $set->('x', 5, 19, "somevalue"); # diag "Delete"; $delete->('x'); # diag "Flush"; $set->('x', 5, 19, "somevaluex"); $set->('y', 5, 17, "somevaluey"); $mc->flush; $empty->('x'); $empty->('y'); { diag "Some chunked item tests"; my $s2 = new_memcached('-o no_modern,slab_chunk_max=4096'); ok($s2, "started the server"); my $m2 = MC::Client->new($s2); # Specifically trying to cross the chunk boundary when internally # appending CLRF. for my $k (7900..8100) { my $val = 'd' x $k; $val .= '123'; $m2->set('t', $val, 0, 0); # Ensure we get back the same value. Bugs can chop chars. my (undef, $gval, undef) = $m2->get('t'); ok($gval eq $val, $gval . " = " . $val); } my $cval = ('d' x 8100) . '123'; my $m3 = $s2->new_sock; mem_get_is($m3, 't', $cval, "large value set from bin fetched from ascii"); } { # diag "Add"; $empty->('i'); $mc->add('i', 'ex', 5, 10); $check->('i', 5, "ex"); my $rv =()= eval { $mc->add('i', "ex2", 10, 5) }; is($rv, 0, "Add didn't return anything"); ok($@->exists, "Expected exists error received"); $check->('i', 5, "ex"); } { # diag "Too big."; $empty->('toobig'); $mc->set('toobig', 'not too big', 10, 10); eval { my $bigval = ("x" x (1024*1024)) . "x"; $mc->set('toobig', $bigval, 10, 10); }; ok($@->too_big, "Was too big"); $empty->('toobig'); } { # diag "Replace"; $empty->('j'); my $rv =()= eval { $mc->replace('j', "ex", 19, 5) }; is($rv, 0, "Replace didn't return anything"); ok($@->not_found, "Expected not_found error received"); $empty->('j'); $mc->add('j', "ex2", 14, 5); $check->('j', 14, "ex2"); $mc->replace('j', "ex3", 24, 5); $check->('j', 24, "ex3"); } { # diag "MultiGet"; $mc->add('xx', "ex", 1, 5); $mc->add('wye', "why", 2, 5); my $rv = $mc->get_multi(qw(xx wye zed)); # CAS is returned with all gets. $rv->{xx}->[2] = 0; $rv->{wye}->[2] = 0; is_deeply($rv->{xx}, [1, 'ex', 0], "X is correct"); is_deeply($rv->{wye}, [2, 'why', 0], "Y is correct"); is(keys(%$rv), 2, "Got only two answers like we expect"); } # diag "Test increment"; $mc->flush; is($mc->incr("x"), 0, "First incr call is zero"); is($mc->incr("x"), 1, "Second incr call is one"); is($mc->incr("x", 211), 212, "Adding 211 gives you 212"); is($mc->incr("x", 2**33), 8589934804, "Blast the 32bit border"); # diag "Issue 48 - incrementing plain text."; { $mc->set("issue48", "text", 0, 0); my $rv =()= eval { $mc->incr('issue48'); }; ok($@ && $@->delta_badval, "Expected invalid value when incrementing text."); $check->('issue48', 0, "text"); $rv =()= eval { $mc->decr('issue48'); }; ok($@ && $@->delta_badval, "Expected invalid value when decrementing text."); $check->('issue48', 0, "text"); } # diag "Issue 320 - incr/decr wrong length for initial value"; { $mc->flush; is($mc->incr("issue320", 1, 1, 0), 1, "incr initial value is 1"); my (undef, $rv, undef) = $mc->get("issue320"); is(length($rv), 1, "initial value length is 1"); is($rv, "1", "initial value is 1"); } # diag "Test decrement"; $mc->flush; is($mc->incr("x", undef, 5), 5, "Initial value"); is($mc->decr("x"), 4, "Decrease by one"); is($mc->decr("x", 211), 0, "Floor is zero"); { # diag "bug220 my ($rv, $cas) = $mc->set("bug220", "100", 0, 0); my ($irv, $icas) = $mc->incr_cas("bug220", 999); ok($icas != $cas); is($irv, 1099, "Incr amount failed"); my ($flags, $val, $gcas) = $mc->get("bug220"); is($gcas, $icas, "CAS didn't match after incr/gets"); ($irv, $icas) = $mc->incr_cas("bug220", 999); ok($icas != $cas); is($irv, 2098, "Incr amount failed"); ($flags, $val, $gcas) = $mc->get("bug220"); is($gcas, $icas, "CAS didn't match after incr/gets"); } { # diag "bug21"; $mc->add("bug21", "9223372036854775807", 0, 0); is($mc->incr("bug21"), 9223372036854775808, "First incr for bug21."); is($mc->incr("bug21"), 9223372036854775809, "Second incr for bug21."); is($mc->decr("bug21"), 9223372036854775808, "Decr for bug21."); } { # diag "CAS"; $mc->flush; { my $rv =()= eval { $mc->set("x", "bad value", 19, 5, 0x7FFFFFF) }; is($rv, 0, "Empty return on expected failure"); ok($@->not_found, "Error was 'not found' as expected"); } my ($r, $rcas) = $mc->add("x", "original value", 5, 19); my ($flags, $val, $i) = $mc->get("x"); is($val, "original value", "->gets returned proper value"); is($rcas, $i, "Add CAS matched."); { my $rv =()= eval { $mc->set("x", "broken value", 19, 5, $i+1) }; is($rv, 0, "Empty return on expected failure (1)"); ok($@->exists, "Expected error state of 'exists' (1)"); } ($r, $rcas) = $mc->set("x", "new value", 19, 5, $i); my ($newflags, $newval, $newi) = $mc->get("x"); is($newval, "new value", "CAS properly overwrote value"); is($rcas, $newi, "Get CAS matched."); { my $rv =()= eval { $mc->set("x", "replay value", 19, 5, $i) }; is($rv, 0, "Empty return on expected failure (2)"); ok($@->exists, "Expected error state of 'exists' (2)"); } } # diag "Touch commands"; { $mc->flush; $mc->set("totouch", "toast", 0, 1); my $res = $mc->touch("totouch", 10); sleep 2; $check->("totouch", 0, "toast"); $mc->set("totouch", "toast2", 0, 1); my ($flags, $val, $i) = $mc->gat("totouch", 10); is($val, "toast2", "GAT returned correct value"); sleep 2; $check->("totouch", 0, "toast2"); # Test miss as well $mc->set("totouch", "toast3", 0, 1); $res = $mc->touch("totouch", 1); sleep 3; $empty->("totouch"); } # diag "Silent set."; $mc->silent_mutation(::CMD_SETQ, 'silentset', 'silentsetval'); # diag "Silent add."; $mc->silent_mutation(::CMD_ADDQ, 'silentadd', 'silentaddval'); # diag "Silent replace."; { my $key = "silentreplace"; my $extra = pack "NN", 829, 0; $empty->($key); # $mc->send_silent(::CMD_REPLACEQ, $key, 'somevalue', 7278552, $extra, 0); # $empty->($key); $mc->add($key, "xval", 831, 0); $check->($key, 831, 'xval'); $mc->send_silent(::CMD_REPLACEQ, $key, 'somevalue', 7278552, $extra, 0); $check->($key, 829, 'somevalue'); } # diag "Silent delete"; { my $key = "silentdelete"; $empty->($key); $mc->set($key, "some val", 19, 0); $mc->send_silent(::CMD_DELETEQ, $key, '', 772); $empty->($key); } # diag "Silent increment"; { my $key = "silentincr"; my $opaque = 98428747; $empty->($key); $mc->silent_incrdecr(::CMD_INCREMENTQ, $key, 0, 0, 0); is($mc->incr($key, 0), 0, "First call is 0"); $mc->silent_incrdecr(::CMD_INCREMENTQ, $key, 8, 0, 0); is($mc->incr($key, 0), 8); } # diag "Silent decrement"; { my $key = "silentdecr"; my $opaque = 98428147; $empty->($key); $mc->silent_incrdecr(::CMD_DECREMENTQ, $key, 0, 185, 0); is($mc->incr($key, 0), 185); $mc->silent_incrdecr(::CMD_DECREMENTQ, $key, 8, 0, 0); is($mc->incr($key, 0), 177); } # diag "Silent flush"; { my %stats1 = $mc->stats(''); $set->('x', 5, 19, "somevaluex"); $set->('y', 5, 17, "somevaluey"); $mc->send_silent(::CMD_FLUSHQ, '', '', 2775256); $empty->('x'); $empty->('y'); my %stats2 = $mc->stats(''); is($stats2{'cmd_flush'}, $stats1{'cmd_flush'} + 1, "Stats not updated on a binary quiet flush"); } # diag "Append"; { my $key = "appendkey"; my $value = "some value"; $set->($key, 8, 19, $value); $mc->_append_prepend(::CMD_APPEND, $key, " more"); $check->($key, 19, $value . " more"); } # diag "Prepend"; { my $key = "prependkey"; my $value = "some value"; $set->($key, 8, 19, $value); $mc->_append_prepend(::CMD_PREPEND, $key, "prefixed "); $check->($key, 19, "prefixed " . $value); } # diag "Silent append"; { my $key = "appendqkey"; my $value = "some value"; $set->($key, 8, 19, $value); $mc->send_silent(::CMD_APPENDQ, $key, " more", 7284492); $check->($key, 19, $value . " more"); } # diag "Silent prepend"; { my $key = "prependqkey"; my $value = "some value"; $set->($key, 8, 19, $value); $mc->send_silent(::CMD_PREPENDQ, $key, "prefixed ", 7284492); $check->($key, 19, "prefixed " . $value); } # diag "Leaky binary get test."; # # http://code.google.com/p/memcached/issues/detail?id=16 { # Get a new socket so we can speak text to it. my $sock = $server->new_sock; my $max = 1024 * 1024; my $big = "a big value that's > .5M and < 1M. "; while (length($big) * 2 < $max) { $big = $big . $big; } my $biglen = length($big); for(1..100) { my $key = "some_key_$_"; # print STDERR "Key is $key\n"; # print $sock "set $key 0 0 $vallen\r\n$value\r\n"; print $sock "set $key 0 0 $biglen\r\n$big\r\n"; is(scalar <$sock>, "STORED\r\n", "stored big"); my ($f, $v, $c) = $mc->get($key); } } # diag "Test stats settings." { my %stats = $mc->stats('settings'); is(1024, $stats{'maxconns'}); # we run SSL tests over TCP; hence the domain_socket # is expected to be NULL. if (enabled_tls_testing() || !supports_unix_socket()) { is('NULL', $stats{'domain_socket'}); } else { isnt('NULL', $stats{'domain_socket'}); } is('on', $stats{'evictions'}); is('yes', $stats{'cas_enabled'}); is('yes', $stats{'flush_enabled'}); } # diag "Test quit commands."; { my $s2 = new_memcached(); my $mc2 = MC::Client->new($s2); $mc2->send_command(CMD_QUITQ, '', '', 0, '', 0); # Five seconds ought to be enough to get hung up on. my $oldalarmt = alarm(5); # Verify we can't read anything. my $bytesread = -1; eval { local $SIG{'ALRM'} = sub { die "timeout" }; my $data = ""; $bytesread = sysread($mc2->{socket}, $data, 24), }; is($bytesread, 0, "Read after quit."); # Restore signal stuff. alarm($oldalarmt); } # diag "Test protocol boundary overruns"; { use List::Util qw[min]; # Attempting some protocol overruns by toying around with the edge # of the data buffer at a few different sizes. This assumes the # boundary is at or around 2048 bytes. for (my $i = 1900; $i < 2100; $i++) { my $k = "test_key_$i"; my $v = 'x' x $i; # diag "Trying $i $k"; my $extra = pack "NN", 82, 0; my $data = $mc->build_command(::CMD_SETQ, $k, $v, 0, $extra, 0); $data .= $mc->build_command(::CMD_SETQ, "alt_$k", "blah", 0, $extra, 0); if (length($data) > 2024) { for (my $j = 2024; $j < min(2096, length($data)); $j++) { $mc->{socket}->syswrite(substr($data, 0, $j)); $mc->flush_socket; sleep(0.001); $mc->{socket}->syswrite(substr($data, $j)); $mc->flush_socket; } } else { $mc->{socket}->syswrite($data); } $mc->flush_socket; $check->($k, 82, $v); $check->("alt_$k", 82, "blah"); } } # Along with the assertion added to the code to verify we're staying # within bounds when we do a stats detail dump (detail turned on at # the top). my %stats = $mc->stats('detail dump'); # This test causes a disconnection. { # diag "Key too large."; my $key = "x" x 365; eval { $mc->get($key, 'should die', 10, 10); }; ok($@->einval, "Invalid key length"); } done_testing(); # ###################################################################### # Test ends around here. # ###################################################################### package MC::Client; use strict; use warnings; use fields qw(socket); use IO::Socket::INET; sub new { my $self = shift; my ($s) = @_; $s = $server unless defined $s; my $sock = $s->sock; $self = fields::new($self); $self->{socket} = $sock; return $self; } sub build_command { my $self = shift; die "Not enough args to send_command" unless @_ >= 4; my ($cmd, $key, $val, $opaque, $extra_header, $cas) = @_; $extra_header = '' unless defined $extra_header; my $keylen = length($key); my $vallen = length($val); my $extralen = length($extra_header); my $datatype = 0; # field for future use my $reserved = 0; # field for future use my $totallen = $keylen + $vallen + $extralen; my $ident_hi = 0; my $ident_lo = 0; if ($cas) { $ident_hi = int($cas / 2 ** 32); $ident_lo = int($cas % 2 ** 32); } my $msg = pack(::REQ_PKT_FMT, ::REQ_MAGIC, $cmd, $keylen, $extralen, $datatype, $reserved, $totallen, $opaque, $ident_hi, $ident_lo); my $full_msg = $msg . $extra_header . $key . $val; return $full_msg; } sub send_command { my $self = shift; die "Not enough args to send_command" unless @_ >= 4; my ($cmd, $key, $val, $opaque, $extra_header, $cas) = @_; my $full_msg = $self->build_command($cmd, $key, $val, $opaque, $extra_header, $cas); my $sent = 0; my $data_len = length($full_msg); while ($sent < $data_len) { my $sent_bytes = $self->{socket}->syswrite($full_msg, $data_len - $sent > MemcachedTest::MAX_READ_WRITE_SIZE ? MemcachedTest::MAX_READ_WRITE_SIZE : ($data_len - $sent), $sent); last if ($sent_bytes <= 0); $sent += $sent_bytes; } die("Send failed: $!") unless $data_len; if($sent != $data_len) { die("only sent $sent of " . length($full_msg) . " bytes"); } } sub flush_socket { my $self = shift; $self->{socket}->flush; } # Send a silent command and ensure it doesn't respond. sub send_silent { my $self = shift; die "Not enough args to send_silent" unless @_ >= 4; my ($cmd, $key, $val, $opaque, $extra_header, $cas) = @_; $self->send_command($cmd, $key, $val, $opaque, $extra_header, $cas); $self->send_command(::CMD_NOOP, '', '', $opaque + 1); my ($ropaque, $data) = $self->_handle_single_response; Test::More::is($ropaque, $opaque + 1); } sub silent_mutation { my $self = shift; my ($cmd, $key, $value) = @_; $empty->($key); my $extra = pack "NN", 82, 0; $mc->send_silent($cmd, $key, $value, 7278552, $extra, 0); $check->($key, 82, $value); } sub _handle_single_response { my $self = shift; my $myopaque = shift; my $hdr = ""; while(::MIN_RECV_BYTES - length($hdr) > 0) { $self->{socket}->sysread(my $response, ::MIN_RECV_BYTES - length($hdr)); $hdr .= $response; } Test::More::is(length($hdr), ::MIN_RECV_BYTES, "Expected read length"); my ($magic, $cmd, $keylen, $extralen, $datatype, $status, $remaining, $opaque, $ident_hi, $ident_lo) = unpack(::RES_PKT_FMT, $hdr); Test::More::is($magic, ::RES_MAGIC, "Got proper response magic"); my $cas = ($ident_hi * 2 ** 32) + $ident_lo; return ($opaque, '', $cas, 0) if($remaining == 0); # fetch the value my $rv=""; while($remaining - length($rv) > 0) { $self->{socket}->sysread(my $buf, $remaining - length($rv)); $rv .= $buf; } if(length($rv) != $remaining) { my $found = length($rv); die("Expected $remaining bytes, got $found"); } if (defined $myopaque) { Test::More::is($opaque, $myopaque, "Expected opaque"); } else { Test::More::pass("Implicit pass since myopaque is undefined"); } if ($status) { die MC::Error->new($status, $rv); } return ($opaque, $rv, $cas, $keylen); } sub _do_command { my $self = shift; die unless @_ >= 3; my ($cmd, $key, $val, $extra_header, $cas) = @_; $extra_header = '' unless defined $extra_header; my $opaque = int(rand(2**32)); $self->send_command($cmd, $key, $val, $opaque, $extra_header, $cas); my (undef, $rv, $rcas) = $self->_handle_single_response($opaque); return ($rv, $rcas); } sub _incrdecr_header { my $self = shift; my ($amt, $init, $exp) = @_; my $amt_hi = int($amt / 2 ** 32); my $amt_lo = int($amt % 2 ** 32); my $init_hi = int($init / 2 ** 32); my $init_lo = int($init % 2 ** 32); my $extra_header = pack(::INCRDECR_PKT_FMT, $amt_hi, $amt_lo, $init_hi, $init_lo, $exp); return $extra_header; } sub _incrdecr_cas { my $self = shift; my ($cmd, $key, $amt, $init, $exp) = @_; my ($data, $rcas) = $self->_do_command($cmd, $key, '', $self->_incrdecr_header($amt, $init, $exp)); my $header = substr $data, 0, 8, ''; my ($resp_hi, $resp_lo) = unpack "NN", $header; my $resp = ($resp_hi * 2 ** 32) + $resp_lo; return $resp, $rcas; } sub _incrdecr { my $self = shift; my ($v, $c) = $self->_incrdecr_cas(@_); return $v } sub silent_incrdecr { my $self = shift; my ($cmd, $key, $amt, $init, $exp) = @_; my $opaque = 8275753; $mc->send_silent($cmd, $key, '', $opaque, $mc->_incrdecr_header($amt, $init, $exp)); } sub stats { my $self = shift; my $key = shift; my $cas = 0; my $opaque = int(rand(2**32)); $self->send_command(::CMD_STAT, $key, '', $opaque, '', $cas); my %rv = (); my $found_key = ''; my $found_val = ''; do { my ($op, $data, $cas, $keylen) = $self->_handle_single_response($opaque); if($keylen > 0) { $found_key = substr($data, 0, $keylen); $found_val = substr($data, $keylen); $rv{$found_key} = $found_val; } else { $found_key = ''; } } while($found_key ne ''); return %rv; } sub get { my $self = shift; my $key = shift; my ($rv, $cas) = $self->_do_command(::CMD_GET, $key, '', ''); my $header = substr $rv, 0, 4, ''; my $flags = unpack("N", $header); return ($flags, $rv, $cas); } sub get_multi { my $self = shift; my @keys = @_; for (my $i = 0; $i < @keys; $i++) { $self->send_command(::CMD_GETQ, $keys[$i], '', $i, '', 0); } my $terminal = @keys + 10; $self->send_command(::CMD_NOOP, '', '', $terminal); my %return; while (1) { my ($opaque, $data) = $self->_handle_single_response; last if $opaque == $terminal; my $header = substr $data, 0, 4, ''; my $flags = unpack("N", $header); $return{$keys[$opaque]} = [$flags, $data]; } return %return if wantarray; return \%return; } sub touch { my $self = shift; my ($key, $expire) = @_; my $extra_header = pack "N", $expire; my $cas = 0; return $self->_do_command(::CMD_TOUCH, $key, '', $extra_header, $cas); } sub gat { my $self = shift; my $key = shift; my $expire = shift; my $extra_header = pack "N", $expire; my ($rv, $cas) = $self->_do_command(::CMD_GAT, $key, '', $extra_header); my $header = substr $rv, 0, 4, ''; my $flags = unpack("N", $header); return ($flags, $rv, $cas); } sub version { my $self = shift; return $self->_do_command(::CMD_VERSION, '', ''); } sub flush { my $self = shift; return $self->_do_command(::CMD_FLUSH, '', ''); } sub add { my $self = shift; my ($key, $val, $flags, $expire) = @_; my $extra_header = pack "NN", $flags, $expire; my $cas = 0; return $self->_do_command(::CMD_ADD, $key, $val, $extra_header, $cas); } sub set { my $self = shift; my ($key, $val, $flags, $expire, $cas) = @_; my $extra_header = pack "NN", $flags, $expire; return $self->_do_command(::CMD_SET, $key, $val, $extra_header, $cas); } sub _append_prepend { my $self = shift; my ($cmd, $key, $val, $cas) = @_; return $self->_do_command($cmd, $key, $val, '', $cas); } sub replace { my $self = shift; my ($key, $val, $flags, $expire) = @_; my $extra_header = pack "NN", $flags, $expire; my $cas = 0; return $self->_do_command(::CMD_REPLACE, $key, $val, $extra_header, $cas); } sub delete { my $self = shift; my ($key) = @_; return $self->_do_command(::CMD_DELETE, $key, ''); } sub incr { my $self = shift; my ($key, $amt, $init, $exp) = @_; $amt = 1 unless defined $amt; $init = 0 unless defined $init; $exp = 0 unless defined $exp; return $self->_incrdecr(::CMD_INCR, $key, $amt, $init, $exp); } sub incr_cas { my $self = shift; my ($key, $amt, $init, $exp) = @_; $amt = 1 unless defined $amt; $init = 0 unless defined $init; $exp = 0 unless defined $exp; return $self->_incrdecr_cas(::CMD_INCR, $key, $amt, $init, $exp); } sub decr { my $self = shift; my ($key, $amt, $init, $exp) = @_; $amt = 1 unless defined $amt; $init = 0 unless defined $init; $exp = 0 unless defined $exp; return $self->_incrdecr(::CMD_DECR, $key, $amt, $init, $exp); } sub noop { my $self = shift; return $self->_do_command(::CMD_NOOP, '', ''); } package MC::Error; use strict; use warnings; use constant ERR_UNKNOWN_CMD => 0x81; use constant ERR_NOT_FOUND => 0x1; use constant ERR_EXISTS => 0x2; use constant ERR_TOO_BIG => 0x3; use constant ERR_EINVAL => 0x4; use constant ERR_NOT_STORED => 0x5; use constant ERR_DELTA_BADVAL => 0x6; use overload '""' => sub { my $self = shift; return "Memcache Error ($self->[0]): $self->[1]"; }; sub new { my $class = shift; my $error = [@_]; my $self = bless $error, (ref $class || $class); return $self; } sub not_found { my $self = shift; return $self->[0] == ERR_NOT_FOUND; } sub exists { my $self = shift; return $self->[0] == ERR_EXISTS; } sub too_big { my $self = shift; return $self->[0] == ERR_TOO_BIG; } sub delta_badval { my $self = shift; return $self->[0] == ERR_DELTA_BADVAL; } sub einval { my $self = shift; return $self->[0] == ERR_EINVAL; } # vim: filetype=perl memcached-1.6.20/t/extstore.t0000664000175000017500000001370014340006077012740 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; use Data::Dumper qw/Dumper/; my $ext_path; if (!supports_extstore()) { plan skip_all => 'extstore not enabled'; exit 0; } $ext_path = "/tmp/extstore.$$"; my $server = new_memcached("-m 64 -U 0 -o ext_page_size=8,ext_wbuf_size=2,ext_threads=1,ext_io_depth=2,ext_item_size=512,ext_item_age=2,ext_recache_rate=10000,ext_max_frag=0.9,ext_path=$ext_path:64m,slab_automove=0,ext_compact_under=1,ext_max_sleep=100000"); my $sock = $server->sock; eval { my $server = new_memcached("-o ext_path=$ext_path:64m"); }; ok($@, "failed to start a second server with the same file path"); # Wait until all items have flushed sub wait_for_ext { my $target = shift || 0; my $sum = $target + 1; while ($sum > $target) { my $s = mem_stats($sock, "items"); $sum = 0; for my $key (keys %$s) { if ($key =~ m/items:(\d+):number/) { # Ignore classes which can contain extstore items next if $1 < 3; $sum += $s->{$key}; } } sleep 1 if $sum > $target; } } my $value; { my @chars = ("C".."Z"); for (1 .. 20000) { $value .= $chars[rand @chars]; } } # fill a small object print $sock "set foo 0 0 2\r\nhi\r\n"; is(scalar <$sock>, "STORED\r\n", "stored small value"); # fetch mem_get_is($sock, "foo", "hi"); # check extstore counters { my $stats = mem_stats($sock); is($stats->{extstore_objects_written}, 0); } # fill some larger objects { # set one canary value for later print $sock "set canary 0 0 20000 noreply\r\n$value\r\n"; my $keycount = 1000; for (1 .. $keycount) { print $sock "set nfoo$_ 0 0 20000 noreply\r\n$value\r\n"; } # wait for a flush wait_for_ext(); # fetch # TODO: Fetch back all values mem_get_is($sock, "nfoo1", $value); # check extstore counters my $stats = mem_stats($sock); cmp_ok($stats->{extstore_page_allocs}, '>', 0, 'at least one page allocated'); cmp_ok($stats->{extstore_objects_written}, '>', $keycount / 2, 'some objects written'); cmp_ok($stats->{extstore_bytes_written}, '>', length($value) * 2, 'some bytes written'); cmp_ok($stats->{get_extstore}, '>', 0, 'one object was fetched'); cmp_ok($stats->{extstore_objects_read}, '>', 0, 'one object read'); cmp_ok($stats->{extstore_bytes_read}, '>', length($value), 'some bytes read'); # Remove half of the keys for the next test. for (1 .. $keycount) { next unless $_ % 2 == 0; print $sock "delete nfoo$_ noreply\r\n"; } my $stats2 = mem_stats($sock); cmp_ok($stats->{extstore_bytes_used}, '>', $stats2->{extstore_bytes_used}, 'bytes used dropped after deletions'); cmp_ok($stats->{extstore_objects_used}, '>', $stats2->{extstore_objects_used}, 'objects used dropped after deletions'); is($stats2->{badcrc_from_extstore}, 0, 'CRC checks successful'); is($stats2->{miss_from_extstore}, 0, 'no misses'); # delete the rest for (1 .. $keycount) { next unless $_ % 2 == 1; print $sock "delete nfoo$_ noreply\r\n"; } } # fill to eviction { my $keycount = 4000; for (1 .. $keycount) { print $sock "set mfoo$_ 0 0 20000 noreply\r\n$value\r\n"; # wait to avoid evictions wait_for_ext(500) if ($_ % 2000 == 0); } # because item_age is set to 2s wait_for_ext(); my $stats = mem_stats($sock); is($stats->{evictions}, 0, 'no evictions'); is($stats->{miss_from_extstore}, 0, 'no misses'); # FIXME: test is flaky; something can rescue the canary because of a race # condition. might need to roundtrip twice or disable compaction? #mem_get_is($sock, "canary", undef); # check counters $stats = mem_stats($sock); cmp_ok($stats->{extstore_page_evictions}, '>', 0, 'at least one page evicted'); cmp_ok($stats->{extstore_objects_evicted}, '>', 0, 'at least one object evicted'); cmp_ok($stats->{extstore_bytes_evicted}, '>', 0, 'some bytes evicted'); cmp_ok($stats->{extstore_pages_free}, '<', 2, 'few pages are free'); #is($stats->{miss_from_extstore}, 1, 'exactly one miss'); # refresh some keys so rescues happen while drop_unread == 1. for (1 .. $keycount / 2) { next unless $_ % 2 == 1; # Need to be fetched twice in order to bump print $sock "touch mfoo$_ 0 noreply\r\n"; print $sock "touch mfoo$_ 0 noreply\r\n"; } print $sock "extstore drop_unread 1\r\n"; my $res = <$sock>; print $sock "extstore max_frag 0\r\n"; $res = <$sock>; print $sock "extstore compact_under 4\r\n"; $res = <$sock>; print $sock "extstore drop_under 3\r\n"; $res = <$sock>; for (1 .. $keycount) { next unless $_ % 2 == 0; print $sock "delete mfoo$_ noreply\r\n"; } sleep 4; $stats = mem_stats($sock); cmp_ok($stats->{extstore_pages_free}, '>', 0, 'some pages now free'); cmp_ok($stats->{extstore_compact_rescues}, '>', 0, 'some compaction rescues happened'); cmp_ok($stats->{extstore_compact_skipped}, '>', 0, 'some compaction skips happened'); print $sock "extstore drop_unread 0\r\n"; $res = <$sock>; } # attempt to incr/decr/append/prepend or chunk objects that were sent to disk. { my $keycount = 100; for (1 .. $keycount) { print $sock "set bfoo$_ 0 0 20000 noreply\r\n$value\r\n"; } wait_for_ext(); # incr should be blocked. print $sock "incr bfoo1 1\r\n"; is(scalar <$sock>, "CLIENT_ERROR cannot increment or decrement non-numeric value\r\n", 'incr fails'); # append/prepend *could* work, but it would require pulling the item back in. print $sock "append bfoo1 0 0 2\r\nhi\r\n"; is(scalar <$sock>, "NOT_STORED\r\n", 'append fails'); print $sock "prepend bfoo1 0 0 2\r\nhi\r\n"; is(scalar <$sock>, "NOT_STORED\r\n", 'prepend fails'); } done_testing(); END { unlink $ext_path if $ext_path; } memcached-1.6.20/t/proxyconfig.t0000664000175000017500000003332214427543277013452 00000000000000#!/usr/bin/env perl # NOTE: These tests cover the act of reloading the configuration; changing # backends, pools, routes, etc. It doesn't cover ensuring the code of the main # file changes naturally, which is fine: there isn't any real way that can # fail and it can be covered specifically in a different test file. use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use Carp qw(croak); use MemcachedTest; use IO::Select; use IO::Socket qw(AF_INET SOCK_STREAM); # TODO: possibly... set env var to a generated temp filename before starting # the server so we can pass that in? my $modefile = "/tmp/proxyconfigmode.lua"; if (!supports_proxy()) { plan skip_all => 'proxy not enabled'; exit 0; } # Set up some server sockets. sub mock_server { my $port = shift; my $srv = IO::Socket->new( Domain => AF_INET, Type => SOCK_STREAM, Proto => 'tcp', LocalHost => '127.0.0.1', LocalPort => $port, ReusePort => 1, Listen => 5) || die "IO::Socket: $@"; return $srv; } sub accept_backend { my $srv = shift; my $be = $srv->accept(); $be->autoflush(1); ok(defined $be, "mock backend created"); like(<$be>, qr/version/, "received version command"); print $be "VERSION 1.0.0-mock\r\n"; return $be; } # Put a version command down the pipe to ensure the socket is clear. # client version commands skip the proxy code sub check_version { my $ps = shift; print $ps "version\r\n"; like(<$ps>, qr/VERSION /, "version received"); } sub write_modefile { my $cmd = shift; open(my $fh, "> $modefile") or die "Couldn't overwrite $modefile: $!"; print $fh $cmd; close($fh); } sub wait_reload { my $w = shift; like(<$w>, qr/ts=(\S+) gid=\d+ type=proxy_conf status=start/, "reload started"); like(<$w>, qr/ts=(\S+) gid=\d+ type=proxy_conf status=done/, "reload completed"); } my @mocksrvs = (); #diag "making mock servers"; for my $port (11511, 11512, 11513) { my $srv = mock_server($port); ok(defined $srv, "mock server created"); push(@mocksrvs, $srv); } diag "testing failure to start"; write_modefile("invalid syntax"); eval { my $p_srv = new_memcached('-o proxy_config=./t/proxyconfig.lua'); }; ok($@ && $@ =~ m/Failed to connect/, "server successfully not started"); write_modefile('return "none"'); my $p_srv = new_memcached('-o proxy_config=./t/proxyconfig.lua'); my $ps = $p_srv->sock; $ps->autoflush(1); # Create a watcher so we can monitor when reloads complete. my $watcher = $p_srv->new_sock; print $watcher "watch proxyevents\n"; is(<$watcher>, "OK\r\n", "watcher enabled"); { # test with stubbed main routes. print $ps "mg foo v\r\n"; is(scalar <$ps>, "SERVER_ERROR no mg route\r\n", "no mg route loaded"); } # Load some backends { write_modefile('return "start"'); $p_srv->reload(); wait_reload($watcher); } my @mbe = (); # A map of where keys route to for worker IO tests later my %keymap = (); my $keycount = 100; { # set up server backend sockets. my $s = IO::Select->new(); for my $msrv ($mocksrvs[0], $mocksrvs[1], $mocksrvs[2]) { my $be = accept_backend($msrv); $s->add($be); push(@mbe, $be); } # Try sending something. my $cmd = "mg foo v\r\n"; print $ps $cmd; my @readable = $s->can_read(0.25); is(scalar @readable, 1, "only one backend became readable after mg"); my $be = shift @readable; is(scalar <$be>, $cmd, "metaget passthrough"); print $be "EN\r\n"; is(scalar <$ps>, "EN\r\n", "miss received"); # Route a bunch of keys and map them to backends. for my $key (0 .. $keycount) { print $ps "mg /test/$key\r\n"; my @readable = $s->can_read(0.25); is(scalar @readable, 1, "only one backend became readable for this key"); my $be = shift @readable; for (0 .. 2) { if ($be == $mbe[$_]) { $keymap{$key} = $_; } } is(scalar <$be>, "mg /test/$key\r\n", "got mg passthrough"); print $be "EN\r\n"; is(scalar <$ps>, "EN\r\n", "miss received"); } } # Test backend table arguments and per-backend time overrides my @holdbe = (); # avoid having the backends immediately disconnect and pollute log lines. { # This should create three new backend sockets write_modefile('return "betable"'); $p_srv->reload(); wait_reload($watcher); my $watch_s = IO::Select->new(); $watch_s->add($watcher); my $s = IO::Select->new(); for my $msrv (@mocksrvs) { $s->add($msrv); } my @readable = $s->can_read(0.25); # All three backends should have changed despite having the same label, # host, and port arguments. is(scalar @readable, 3, "all listeners became readable"); my @watchable = $watch_s->can_read(5); is(scalar @watchable, 1, "got new watcher log lines"); like(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_backend error=readvalidate name=\S+ port=11511/, "one backend timed out connecting"); like(<$watcher>, qr/ts=(\S+) gid=\d+ type=proxy_backend error=markedbad name=\S+ port=11511/, "backend was marked bad"); for my $msrv (@readable) { my $be = accept_backend($msrv); push(@holdbe, $be); } # reload again and ensure no sockets become readable $p_srv->reload(); wait_reload($watcher); @readable = $s->can_read(0.5); is(scalar @readable, 0, "no new sockets"); } # Disconnect the existing sockets @mbe = (); @holdbe = (); @mocksrvs = (); $watcher = $p_srv->new_sock; # Reset the watcher and let logs die off. sleep 1; print $watcher "watch proxyevents\n"; is(<$watcher>, "OK\r\n", "watcher enabled"); { # re-create the mock servers so we get clean connects, the previous # backends could be reconnecting still. for my $port (11514, 11515, 11516) { my $srv = mock_server($port); ok(defined $srv, "mock server created"); push(@mocksrvs, $srv); } write_modefile('return "noiothread"'); $p_srv->reload(); wait_reload($watcher); my $s = IO::Select->new(); for my $msrv (@mocksrvs) { $s->add($msrv); } my @readable = $s->can_read(0.25); # All three backends should become readable with new sockets. is(scalar @readable, 3, "all listeners became readable"); my @bepile = (); my $bes = IO::Select->new(); # selector just for the backend sockets. # Each backend should create one socket per worker thread. for my $msrv (@readable) { my @temp = (); for (0 .. 3) { my $be = accept_backend($msrv); $bes->add($be); push(@temp, $be); } for (0 .. 2) { if ($mocksrvs[$_] == $msrv) { $bepile[$_] = \@temp; } } } # clients round robin onto different worker threads, so we can test the # key dist on different offsets. my @cli = (); for (0 .. 2) { my $p = $p_srv->new_sock; for my $key (0 .. $keycount) { print $p "mg /test/$key\r\n"; @readable = $bes->can_read(0.25); is(scalar @readable, 1, "only one backend became readable"); my $be = shift @readable; # find which listener this be belongs to for my $x (0 .. 2) { for (@{$bepile[$x]}) { if ($_ == $be) { cmp_ok($x, '==', $keymap{$key}, "key routed to correct listener: " . $keymap{$key}); } } } is(scalar <$be>, "mg /test/$key\r\n", "got mg passthrough"); print $be "EN\r\n"; is(scalar <$p>, "EN\r\n", "miss received"); } # hold onto the sockets just in case. push(@cli, $p); } @readable = $s->can_read(0.25); is(scalar @readable, 0, "no listeners should be active pre-reload"); $p_srv->reload(); wait_reload($watcher); @readable = $s->can_read(0.25); is(scalar @readable, 0, "no listeners should be active post-reload"); } ### # diag "starting proxy again from scratch" ### # TODO: probably time to abstract the entire "start the server with mocked # listeners" routine. $watcher = undef; write_modefile('return "reqlimit"'); $p_srv->stop; while (1) { if ($p_srv->is_running) { sleep 1; } else { ok(!$p_srv->is_running, "stopped proxy"); last; } } @mocksrvs = (); # re-create the mock servers so we get clean connects, the previous # backends could be reconnecting still. for my $port (11511, 11512, 11513) { my $srv = mock_server($port); ok(defined $srv, "mock server created"); push(@mocksrvs, $srv); } # Start up a clean server. # Since limits are per worker thread, cut the worker threads down to 1 to ease # testing. $p_srv = new_memcached('-o proxy_config=./t/proxyconfig.lua -t 1'); $ps = $p_srv->sock; $ps->autoflush(1); { for my $msrv ($mocksrvs[0], $mocksrvs[1], $mocksrvs[2]) { my $be = accept_backend($msrv); push(@mbe, $be); } my $stats = mem_stats($ps, 'proxy'); isnt($stats->{active_req_limit}, 0, "active request limit is set"); # active request limit is 4, pipeline 6 requests and ensure the last two # get junked my $cmd = ''; for ('a', 'b', 'c', 'd', 'e', 'f') { $cmd .= "mg /test/$_\r\n"; } print $ps $cmd; # Lua config only sends commands to the first backend for this test. my $be = $mbe[0]; for (1 .. 4) { like(<$be>, qr/^mg \/test\/\w\r\n$/, "backend received mg"); print $be "EN\r\n"; } my $s = IO::Select->new(); $s->add($be); my @readable = $s->can_read(0.25); is(scalar @readable, 0, "no more pending reads on backend"); for (1 .. 4) { is(scalar <$ps>, "EN\r\n", "received miss from backend"); } is(scalar <$ps>, "SERVER_ERROR active request limit reached\r\n", "got error back"); is(scalar <$ps>, "SERVER_ERROR active request limit reached\r\n", "got two limit errors"); # Test turning the limit back off. write_modefile('return "noreqlimit"'); $watcher = $p_srv->new_sock; print $watcher "watch proxyevents\n"; is(<$watcher>, "OK\r\n", "watcher enabled"); $p_srv->reload(); wait_reload($watcher); $stats = mem_stats($ps, 'proxy'); is($stats->{active_req_limit}, 0, "active request limit unset"); $cmd = ''; for ('a', 'b', 'c', 'd', 'e', 'f') { $cmd .= "mg /test/$_\r\n"; } print $ps $cmd; for (1 .. 6) { like(<$be>, qr/^mg \/test\/\w\r\n$/, "backend received mg"); print $be "EN\r\n"; } for (1 .. 6) { is(scalar <$ps>, "EN\r\n", "received miss from backend"); } } { # Test the buffer memory limiter. # - limit per worker will be 1/t global limit write_modefile('return "buflimit"'); $p_srv->reload(); wait_reload($watcher); # Get a secondary client to trample limit. my $sps = $p_srv->new_sock; my $stats = mem_stats($ps, 'proxy'); isnt($stats->{buffer_memory_limit}, 0, "buf mem limit is set"); # - test SET commands with values, but nothing being read on backend my $data = 'x' x 30000; my $cmd = "ms foo 30000 T30\r\n" . $data . "\r\n"; print $ps $cmd; my $be = $mbe[0]; my $s = IO::Select->new; $s->add($be); # Wait until the backend has the request queued, then send the second one. my @readable = $s->can_read(1); print $sps $cmd; my $res; is(scalar <$be>, "ms foo 30000 T30\r\n", "received first ms"); $res = scalar <$be>; print $be "HD\r\n"; # The second request should have been caught by the memory limiter is(scalar <$sps>, "SERVER_ERROR out of memory\r\n", "got server error"); # FIXME: The original response cannot succeed because we cannot allocate # enough memory to read the response from the backend. # This is conveniently testing both paths right here but I would prefer # something better. # TODO: need to see if it's possible to surface an OOM from the backend # handler, but that requires more rewiring. is(scalar <$ps>, "SERVER_ERROR backend failure\r\n", "first request succeeded"); # Backend gets killed from a read OOM, so we need to re-establish. $be = $mbe[0] = accept_backend($mocksrvs[0]); like(<$watcher>, qr/error=outofmemory/, "OOM log line"); # Memory limits won't drop until the garbage collectors run, which # requires a bit more push, so instead we raise the limits here so we can # retry from the pre-existing connections to test swallow mode. write_modefile('return "buflimit2"'); $p_srv->reload(); wait_reload($watcher); # Test sending another request down both pipes to ensure they still work. $cmd = "ms foo 2 T30\r\nhi\r\n"; print $ps $cmd; is(scalar <$be>, "ms foo 2 T30\r\n", "client works after oom"); is(scalar <$be>, "hi\r\n", "client works after oom"); print $be "HD\r\n"; is(scalar <$ps>, "HD\r\n", "client received resp after oom"); print $sps $cmd; is(scalar <$be>, "ms foo 2 T30\r\n", "client works after oom"); is(scalar <$be>, "hi\r\n", "client works after oom"); print $be "HD\r\n"; is(scalar <$sps>, "HD\r\n", "client received resp after oom"); # - test GET commands but don't read back, large backend values # - test disabling the limiter # extended testing: # - create errors while holding the buffers? } # TODO: # check reqlimit/bwlimit counters # remove backends # do dead sockets close? # adding user stats # changing user stats # adding backends with the same label don't create more connections # total backend counters # change top level routes mid-request # - send the request to backend # - issue and wait for reload # - read from backend and respond, should use the original code still. # - could also read from backend and then do reload/etc. done_testing(); END { unlink $modefile; } memcached-1.6.20/t/issue_50.t0000664000175000017500000000061114340006077012514 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 1; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached('-B binary'); my $sock = $server->sock; $SIG{ALRM} = sub { die "alarm\n" }; alarm(2); print $sock "Here's a bunch of garbage that doesn't look like the bin prot."; my $rv = <$sock>; ok(1, "Either the above worked and quit, or hung forever."); memcached-1.6.20/t/ssl_ports.t0000664000175000017500000000126514340006077013116 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; if (!enabled_tls_testing()) { plan skip_all => 'SSL testing is not enabled'; exit 0; } my $tcp_port = free_port(); my $ssl_port = free_port(); my $server = new_memcached("-l notls:127.0.0.1:$tcp_port,127.0.0.1:$ssl_port", $ssl_port); my $sock = $server->sock; # Make sure we can talk over SSL print $sock "set foo:123 0 0 16\r\nfoo set over SSL\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); #.. and TCP my $tcp_sock = IO::Socket::INET->new(PeerAddr => "127.0.0.1:$tcp_port"); mem_get_is($tcp_sock, "foo:123", "foo set over SSL"); done_testing() memcached-1.6.20/t/proxyustats.lua0000664000175000017500000000137414427543277014050 00000000000000-- get some information about the test being run from an external file -- so we can modify ourselves. local config = dofile("/tmp/proxyustats.lua") local idx = 1 function mcp_config_pools(old) mcp.backend_read_timeout(4) mcp.backend_connect_timeout(5) local pfx, f, l = string.match(config, "(%S+)%s*(%S+)%s*(%S+)") local first = tonumber(f) local last = tonumber(l) while first <= last do mcp.add_stat(first, pfx .. first) first = first + 1 end return {} end function route_fn(zones) return function(r) local key = r:key() mcp.stat(math.abs(tonumber(key)), tonumber(key)) return "HD\r\n" end end function mcp_config_routes(zones) mcp.attach(mcp.CMD_MG, route_fn(zones)) end memcached-1.6.20/t/issue_140.t0000664000175000017500000000172214340006077012600 00000000000000#!/usr/bin/env perl use strict; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; plan skip_all => 'Fix for Issue 140 was only an illusion'; plan tests => 7; my $server = new_memcached(); my $sock = $server->sock; print $sock "set a 0 0 1\r\na\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key"); my $stats = mem_stats($sock, "items"); my $age = $stats->{"items:1:age"}; isnt ($age, "0", "Age should not be zero"); print $sock "flush_all\r\n"; is (scalar <$sock>, "OK\r\n", "items flushed"); my $stats = mem_stats($sock, "items"); my $age = $stats->{"items:1:age"}; is ($age, undef, "all should be gone"); print $sock "set a 0 1 1\r\na\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key"); my $stats = mem_stats($sock, "items"); my $age = $stats->{"items:1:age"}; isnt ($age, "0", "Age should not be zero"); sleep(3); my $stats = mem_stats($sock, "items"); my $age = $stats->{"items:1:age"}; is ($age, undef, "all should be gone"); memcached-1.6.20/t/cas.t0000664000175000017500000001114114340006077011626 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 43; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $sock2 = $server->new_sock; my @result; my @result2; ok($sock != $sock2, "have two different connections open"); sub check_args { my ($line, $name) = @_; my $svr = new_memcached(); my $s = $svr->sock; print $s $line; is(scalar <$s>, "CLIENT_ERROR bad command line format\r\n", $name); undef $svr; } check_args "cas bad blah 0 0 0\r\n\r\n", "bad flags"; check_args "cas bad 0 blah 0 0\r\n\r\n", "bad exp"; check_args "cas bad 0 0 blah 0\r\n\r\n", "bad cas"; check_args "cas bad 0 0 0 blah\r\n\r\n", "bad size"; # gets foo (should not exist) print $sock "gets foo\r\n"; is(scalar <$sock>, "END\r\n", "gets failed"); # set foo print $sock "set foo 0 0 6\r\nbarval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored barval"); # gets foo and verify identifier exists @result = mem_gets($sock, "foo"); mem_gets_is($sock,$result[0],"foo","barval"); # cas fail print $sock "cas foo 0 0 6 123\r\nbarva2\r\n"; is(scalar <$sock>, "EXISTS\r\n", "cas failed for foo"); # gets foo - success @result = mem_gets($sock, "foo"); mem_gets_is($sock,$result[0],"foo","barval"); # cas success print $sock "cas foo 0 0 6 $result[0]\r\nbarva2\r\n"; is(scalar <$sock>, "STORED\r\n", "cas success, set foo"); # cas failure (reusing the same key) print $sock "cas foo 0 0 6 $result[0]\r\nbarva2\r\n"; is(scalar <$sock>, "EXISTS\r\n", "reusing a CAS ID"); # delete foo print $sock "delete foo\r\n"; is(scalar <$sock>, "DELETED\r\n", "deleted foo"); # cas missing print $sock "cas foo 0 0 6 $result[0]\r\nbarva2\r\n"; is(scalar <$sock>, "NOT_FOUND\r\n", "cas failed, foo does not exist"); # cas empty print $sock "cas foo 0 0 6 \r\nbarva2\r\n"; is(scalar <$sock>, "ERROR\r\n", "cas empty, throw error"); # cant parse barval2\r\n is(scalar <$sock>, "ERROR\r\n", "error out on barval2 parsing"); # set foo1 print $sock "set foo1 0 0 1\r\n1\r\n"; is(scalar <$sock>, "STORED\r\n", "set foo1"); # set foo2 print $sock "set foo2 0 0 1\r\n2\r\n"; is(scalar <$sock>, "STORED\r\n", "set foo2"); # gets foo1 check print $sock "gets foo1\r\n"; ok(scalar <$sock> =~ /VALUE foo1 0 1 (\d+)\r\n/, "gets foo1 regexp success"); my $foo1_cas = $1; is(scalar <$sock>, "1\r\n","gets foo1 data is 1"); is(scalar <$sock>, "END\r\n","gets foo1 END"); # gets foo2 check print $sock "gets foo2\r\n"; ok(scalar <$sock> =~ /VALUE foo2 0 1 (\d+)\r\n/,"gets foo2 regexp success"); my $foo2_cas = $1; is(scalar <$sock>, "2\r\n","gets foo2 data is 2"); is(scalar <$sock>, "END\r\n","gets foo2 END"); # validate foo1 != foo2 ok($foo1_cas != $foo2_cas,"foo1 != foo2 single-gets success"); # multi-gets print $sock "gets foo1 foo2\r\n"; ok(scalar <$sock> =~ /VALUE foo1 0 1 (\d+)\r\n/, "validating first set of data is foo1"); $foo1_cas = $1; is(scalar <$sock>, "1\r\n", "validating foo1 set of data is 1"); ok(scalar <$sock> =~ /VALUE foo2 0 1 (\d+)\r\n/, "validating second set of data is foo2"); $foo2_cas = $1; is(scalar <$sock>, "2\r\n", "validating foo2 set of data is 2"); is(scalar <$sock>, "END\r\n","validating foo1,foo2 gets is over - END"); # validate foo1 != foo2 ok($foo1_cas != $foo2_cas, "foo1 != foo2 multi-gets success"); ### simulate race condition with cas # gets foo1 - success @result = mem_gets($sock, "foo1"); ok($result[0] != "", "sock - gets foo1 is not empty"); # gets foo2 - success @result2 = mem_gets($sock2, "foo1"); ok($result2[0] != "","sock2 - gets foo1 is not empty"); print $sock "cas foo1 0 0 6 $result[0]\r\nbarva2\r\n"; print $sock2 "cas foo1 0 0 5 $result2[0]\r\napple\r\n"; my $res1 = <$sock>; my $res2 = <$sock2>; ok( ( $res1 eq "STORED\r\n" && $res2 eq "EXISTS\r\n") || ( $res1 eq "EXISTS\r\n" && $res2 eq "STORED\r\n"), "cas on same item from two sockets"); ### bug 15: http://code.google.com/p/memcached/issues/detail?id=15 # set foo print $sock "set bug15 0 0 1\r\n0\r\n"; is(scalar <$sock>, "STORED\r\n", "stored 0"); # Check out the first gets. print $sock "gets bug15\r\n"; ok(scalar <$sock> =~ /VALUE bug15 0 1 (\d+)\r\n/, "gets bug15 regexp success"); my $bug15_cas = $1; is(scalar <$sock>, "0\r\n", "gets bug15 data is 0"); is(scalar <$sock>, "END\r\n","gets bug15 END"); # Increment print $sock "incr bug15 1\r\n"; is(scalar <$sock>, "1\r\n", "incr worked"); # Validate a changed CAS print $sock "gets bug15\r\n"; ok(scalar <$sock> =~ /VALUE bug15 0 1 (\d+)\r\n/, "gets bug15 regexp success"); my $next_bug15_cas = $1; is(scalar <$sock>, "1\r\n", "gets bug15 data is 1"); is(scalar <$sock>, "END\r\n","gets bug15 END"); ok($bug15_cas != $next_bug15_cas, "CAS changed"); memcached-1.6.20/t/README-TLS.md0000664000175000017500000000352114301776131012617 00000000000000# Certificates creation process The following certificates are used in tests, that assume expiration date to always be in the future, so instead of a normal cert validity of 1-5 years. we use 500 years here. ## Create certificate authority key and certificate ``` $ openssl genrsa -out cakey.pem 2048 $ openssl req -x509 -new -nodes -key cakey.pem -sha256 -days 182500 -out cacert.pem \ -subj "/CN=Test Root Certificate Authority/ST=CA/C=US/emailAddress=root@test.com/O=Test/OU=Test Department" ``` ## Create server key and certificate ``` $ openssl genrsa -out server_key.pem 2048 $ openssl req -new -sha256 -key server_key.pem \ -subj "/C=US/ST=CA/O=Test/OU=Subunit of Test Organization/CN=test.com/emailAddress=root@test.com" \ -addext "subjectAltName=DNS:test.com,DNS:alt.test.com" \ -out server_crt.csr $ openssl x509 -req -in server_crt.csr -CA cacert.pem -CAkey cakey.pem \ -extfile <(printf "subjectAltName=DNS:test.com,DNS:alt.test.com") \ -CAcreateserial -out server_crt.pem -days 182500 -sha256 -text ``` ## Create client key and certificate ``` $ openssl genrsa -out client_key.pem 2048 $ openssl req -new -sha256 -key client_key.pem \ -subj "/C=US/ST=CA/O=Test Client/OU=Subunit of Test Organization/CN=client.test.com/emailAddress=root@client.test.com" \ -addext "subjectAltName=DNS:client.test.com,DNS:alt.client.test.com" \ -out client_crt.csr $ openssl x509 -req -in client_crt.csr -CA cacert.pem -CAkey cakey.pem \ -extfile <(printf "subjectAltName=DNS:client.test.com,DNS:alt.client.test.com") \ -CAcreateserial -out client_crt.pem -days 182500 -sha256 -text ``` **NOTES**: *.csr files are certificate signing requests which are needed in order to sign certificates with signing authority. -CAcreateserial option creates one file which we do not need but openssl does. You can delete it after you are done. memcached-1.6.20/t/lru-crawler.t0000664000175000017500000001060514340006077013323 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More tests => 70257; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached('-m 32 -o no_modern'); { my $stats = mem_stats($server->sock, ' settings'); is($stats->{lru_crawler}, "no"); } my $sock = $server->sock; # Fill a slab a bit. # Some immortal items, some long expiring items, some short expiring items. # Done so the immortals end up at the tail. for (1 .. 30) { print $sock "set ifoo$_ 0 0 2\r\nok\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key"); } for (1 .. 30) { print $sock "set lfoo$_ 0 3600 2\r\nok\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key"); } for (1 .. 30) { print $sock "set sfoo$_ 0 1 2\r\nok\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key"); } { my $slabs = mem_stats($sock, "slabs"); is($slabs->{"1:used_chunks"}, 90, "slab1 has 90 used chunks"); } sleep 3; print $sock "lru_crawler enable\r\n"; is(scalar <$sock>, "OK\r\n", "enabled lru crawler"); { my $stats = mem_stats($server->sock, ' settings'); is($stats->{lru_crawler}, "yes"); } print $sock "lru_crawler crawl 1\r\n"; is(scalar <$sock>, "OK\r\n", "kicked lru crawler"); while (1) { my $stats = mem_stats($sock); last unless $stats->{lru_crawler_running}; sleep 1; } { my $slabs = mem_stats($sock, "slabs"); is($slabs->{"1:used_chunks"}, 60, "slab1 now has 60 used chunks"); my $items = mem_stats($sock, "items"); is($items->{"items:1:crawler_reclaimed"}, 30, "slab1 has 30 reclaims"); } # Ensure pipelined commands fail with metadump. # using metaget because get forces pipeline flush. { print $sock "mg foo v\r\nlru_crawler metadump all\r\n"; is(scalar <$sock>, "EN\r\n"); is(scalar <$sock>, "ERROR cannot pipeline other commands before metadump\r\n"); } # Check that crawler metadump works correctly. { print $sock "lru_crawler metadump all\r\n"; my $count = 0; while (<$sock>) { last if /^(\.|END)/; /^(key=) (\S+).*([^\r\n]+)/; $count++; } is ($count, 60, "metadump all returns all items"); } for (1 .. 30) { mem_get_is($sock, "ifoo$_", "ok"); mem_get_is($sock, "lfoo$_", "ok"); mem_get_is($sock, "sfoo$_", undef); } # add a few more items into a different slab class my $mfdata = 'x' x 512; for (1 .. 30) { print $sock "set mfoo$_ 0 0 512\r\n$mfdata\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key"); } # set enough small values to ensure bucket chaining happens # ... but not enough that hash table expansion happens. # TODO: check hash power level? my %bfoo = (); for (1 .. 70000) { print $sock "set bfoo$_ 0 0 1 noreply\r\nz\r\n"; $bfoo{$_} = 1; } { print $sock "version\r\n"; my $res = <$sock>; like($res, qr/^VERSION/, "bulk sets completed"); } # Check metadump hash table walk returns correct number of items. { print $sock "lru_crawler metadump hash\r\n"; my $count = 0; while (<$sock>) { last if /^(\.|END)/; if (/^key=bfoo(\S+)/) { ok(exists $bfoo{$1}, "found bfoo key $1 is still in test hash"); delete $bfoo{$1}; } $count++; } is ($count, 70090, "metadump hash returns all items"); is ((keys %bfoo), 0, "metadump found all bfoo keys"); } print $sock "lru_crawler disable\r\n"; is(scalar <$sock>, "OK\r\n", "disabled lru crawler"); my $settings_match = 0; # TODO: we retry a few times since the settings value is changed # outside of a memory barrier, but the thread is stopped before the OK is # returned. # At some point better handling of the setings synchronization should happen. for (1 .. 10) { my $stats = mem_stats($server->sock, ' settings'); if ($stats->{lru_crawler} eq "no") { $settings_match = 1; last; } sleep 1; } is($settings_match, 1, "settings output matches crawler state"); $server->stop; # Test initializing crawler from starttime. $server = new_memcached('-m 32 -o no_modern,lru_crawler'); $sock = $server->sock; for (1 .. 30) { print $sock "set sfoo$_ 0 1 2\r\nok\r\n"; is(scalar <$sock>, "STORED\r\n", "stored key"); } sleep 3; print $sock "lru_crawler crawl 1\r\n"; is(scalar <$sock>, "OK\r\n", "kicked lru crawler"); while (1) { my $stats = mem_stats($sock); last unless $stats->{lru_crawler_running}; sleep 1; } { my $slabs = mem_stats($sock, "slabs"); is($slabs->{"1:used_chunks"}, 0, "slab1 now has 0 used chunks"); } memcached-1.6.20/t/issue_14.t0000664000175000017500000000145214340006077012520 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 21; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $value = "B"x66560; my $key = 0; for ($key = 0; $key < 10; $key++) { print $sock "set key$key 0 2 66560\r\n$value\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key$key"); } #print $sock "stats slabs" my $first_stats = mem_stats($sock, "slabs"); my $first_malloc = $first_stats->{total_malloced}; sleep(4); for ($key = 10; $key < 20; $key++) { print $sock "set key$key 0 2 66560\r\n$value\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key$key"); } my $second_stats = mem_stats($sock, "slabs"); my $second_malloc = $second_stats->{total_malloced}; is ($second_malloc, $first_malloc, "Memory grows..") memcached-1.6.20/t/flags.t0000775000175000017500000000072314340006077012163 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 8; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; # set foo (and should get it) for my $flags (0, 123, 2**16-1, 2**31) { print $sock "set foo $flags 0 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); mem_get_is({ sock => $sock, flags => $flags }, "foo", "fooval", "got flags $flags back"); } memcached-1.6.20/t/conn-limits.t0000664000175000017500000000416314340006077013322 00000000000000#!/usr/bin/env perl # Test connection memory limits. use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached('-o read_buf_mem_limit=1 -t 32 -R 500'); my $sock = $server->sock; # The minimum limit is 1 megabyte. This is then split between each of the # worker threads, which ends up being a lot of memory for a quick test. # So we use a high worker thread count to split them down more. { # easiest method is an ascii multiget. my $key = 'foo'; my @keys = (); for (1 .. 500) { push(@keys, $key); } my $keylist = join(' ', @keys); chop($keylist); print $sock "get ", $keylist, "\r\n"; like(<$sock>, qr/SERVER_ERROR out of memory writing/, "OOM'ed multiget"); my $stats = mem_stats($sock); isnt(0, $stats->{'response_obj_oom'}, 'non zero response object OOM counter: ' . $stats->{'response_obj_oom'}); } { # stacked ascii responses, which should cause a connection close. my $s = $server->new_sock; my @keys = (); for (1 .. 500) { push(@keys, "mg foo v\r\n"); } my $cmd = join('', @keys); print $s $cmd; ok(!defined <$s>, 'sock disconnected after overflow'); my $stats = mem_stats($sock); cmp_ok($stats->{'response_obj_oom'}, '>', 1, 'another OOM recorded'); } SKIP: { skip "read_buf test borks on travis CI. don't have patience to fix.", 1; # test read buffer limits. # spam connections with a partial command.. a set in this case is easy. my @conns = (); for (1 .. 128) { my $s = $server->new_sock; #if (!defined($s)) { # Don't need the spam of every individual conn made. #} ok(defined($s), 'new conn made'); # Partial set command, should attach a read buffer but not release it. print $s "set foo 0 0 2\r\n"; push(@conns, $s); } # Close everything so we have a red buffer available to get stats. for my $s (@conns) { $s->close(); } my $stats = mem_stats($sock); cmp_ok($stats->{'read_buf_oom'}, '>', 1, 'read buffer based OOM recorded'); } done_testing(); memcached-1.6.20/t/proxyconfig.lua0000664000175000017500000000762314427543277013775 00000000000000-- get some information about the test being run from an external file -- so we can modify ourselves. local mode = dofile("/tmp/proxyconfigmode.lua") function mcp_config_pools(old) mcp.backend_read_timeout(4) mcp.backend_connect_timeout(5) if mode == "none" then return {} elseif mode == "start" then local b1 = mcp.backend('b1', '127.0.0.1', 11511) local b2 = mcp.backend('b2', '127.0.0.1', 11512) local b3 = mcp.backend('b3', '127.0.0.1', 11513) local pools = { test = mcp.pool({b1, b2, b3}) } return pools elseif mode == "betable" then local b1 = mcp.backend({ label = "b1", host = "127.0.0.1", port = 11511, connecttimeout = 2, retrytimeout = 5, readtimeout = 1, failurelimit = 0 }) local b2 = mcp.backend({ label = "b2", host = "127.0.0.1", port = 11512, connecttimeout = 2, retrytimeout = 5, readtimeout = 5 }) local b3 = mcp.backend({ label = "b3", host = "127.0.0.1", port = 11513, connecttimeout = 5, retrytimeout = 5, readtimeout = 5 }) local pools = { test = mcp.pool({b1, b2, b3}) } return pools elseif mode == "noiothread" then local b1 = mcp.backend('b1', '127.0.0.1', 11514) local b2 = mcp.backend('b2', '127.0.0.1', 11515) local b3 = mcp.backend('b3', '127.0.0.1', 11516) local pools = { test = mcp.pool({b1, b2, b3}, { iothread = false }) } return pools elseif mode == "reqlimit" then mcp.active_req_limit(4) local b1 = mcp.backend('b1', '127.0.0.1', 11511) local b2 = mcp.backend('b2', '127.0.0.1', 11512) local b3 = mcp.backend('b3', '127.0.0.1', 11513) -- Direct all traffic at a single backend to simplify the test. local pools = { test = mcp.pool({b1}), hold = mcp.pool({b2, b3}) } return pools elseif mode == "noreqlimit" then mcp.active_req_limit(0) local b1 = mcp.backend('b1', '127.0.0.1', 11511) local b2 = mcp.backend('b2', '127.0.0.1', 11512) local b3 = mcp.backend('b3', '127.0.0.1', 11513) -- Direct all traffic at a single backend to simplify the test. local pools = { test = mcp.pool({b1}), hold = mcp.pool({b2, b3}) } return pools elseif mode == "buflimit" or mode == "buflimit2" then mcp.buffer_memory_limit(20) if mode == "buflimit2" then mcp.buffer_memory_limit(200) end local b1 = mcp.backend('b1', '127.0.0.1', 11511) local b2 = mcp.backend('b2', '127.0.0.1', 11512) local b3 = mcp.backend('b3', '127.0.0.1', 11513) -- Direct all traffic at a single backend to simplify the test. local pools = { test = mcp.pool({b1}), hold = mcp.pool({b2, b3}) } return pools elseif mode == "nobuflimit" then mcp.buffer_memory_limit(0) local b1 = mcp.backend('b1', '127.0.0.1', 11511) local b2 = mcp.backend('b2', '127.0.0.1', 11512) local b3 = mcp.backend('b3', '127.0.0.1', 11513) -- Direct all traffic at a single backend to simplify the test. local pools = { test = mcp.pool({b1}), hold = mcp.pool({b2, b3}) } return pools end end -- At least to start we don't need to test every command, but we should do -- some tests against the two broad types of commands (gets vs sets with -- payloads) function mcp_config_routes(zones) if mode == "none" then mcp.attach(mcp.CMD_MG, function(r) return "SERVER_ERROR no mg route\r\n" end) mcp.attach(mcp.CMD_MS, function(r) return "SERVER_ERROR no ms route\r\n" end) else mcp.attach(mcp.CMD_MG, function(r) return zones["test"](r) end) mcp.attach(mcp.CMD_MS, function(r) return zones["test"](r) end) end end memcached-1.6.20/t/dash-M.t0000664000175000017500000000151414340006077012174 00000000000000#!/usr/bin/env perl use strict; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached('-M -m 2'); my $sock = $server->sock; my $value = "B" x 8192; my $vallen = length($value); my $resp = "STORED\r\n"; my $key = 0; while($resp eq "STORED\r\n") { print $sock "set dash$key 0 0 $vallen\r\n$value\r\n"; $key++; $resp = scalar <$sock>; } my $max_stored = $key - 1; plan tests => $max_stored + 2; print $sock "set dash$key 0 0 $vallen\r\n$value\r\n"; is(scalar <$sock>, "SERVER_ERROR out of memory storing object\r\n", "failed to add another one."); my $stats = mem_stats($sock); is($stats->{"store_no_memory"}, 2, "recorded store failures due to no memory"); for($key = 0; $key < $max_stored; $key++) { mem_get_is $sock, "dash$key", $value, "Failed at dash$key"; } memcached-1.6.20/t/ssl_verify_modes.t0000664000175000017500000000103014340006077014430 00000000000000#!/usr/bin/env perl use strict; use warnings; use Test::More; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; use Cwd; if (!enabled_tls_testing()) { plan skip_all => 'SSL testing is not enabled'; exit 0; } my $ca_crt = getcwd() . "/t/" . MemcachedTest::CA_CRT; my $server = new_memcached("-o ssl_verify_mode=2 -o ssl_ca_cert=$ca_crt"); # just using stats to make sure everything is working fine. my $stats = mem_stats($server->sock); is($stats->{accepting_conns}, 1, "client cert is verified"); done_testing(); memcached-1.6.20/t/stats-detail.t0000664000175000017500000000411114340006077013455 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 24; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $expire; print $sock "stats detail dump\r\n"; is(scalar <$sock>, "END\r\n", "verified empty stats at start"); print $sock "stats detail on\r\n"; is(scalar <$sock>, "OK\r\n", "detail collection turned on"); print $sock "set foo:123 0 0 6\r\nfooval\r\n"; is(scalar <$sock>, "STORED\r\n", "stored foo"); print $sock "stats detail dump\r\n"; is(scalar <$sock>, "PREFIX foo get 0 hit 0 set 1 del 0\r\n", "details after set"); is(scalar <$sock>, "END\r\n", "end of details"); mem_get_is($sock, "foo:123", "fooval"); print $sock "stats detail dump\r\n"; is(scalar <$sock>, "PREFIX foo get 1 hit 1 set 1 del 0\r\n", "details after get with hit"); is(scalar <$sock>, "END\r\n", "end of details"); mem_get_is($sock, "foo:124", undef); print $sock "stats detail dump\r\n"; is(scalar <$sock>, "PREFIX foo get 2 hit 1 set 1 del 0\r\n", "details after get without hit"); is(scalar <$sock>, "END\r\n", "end of details"); print $sock "delete foo:125\r\n"; is(scalar <$sock>, "NOT_FOUND\r\n", "sent delete command"); print $sock "stats detail dump\r\n"; is(scalar <$sock>, "PREFIX foo get 2 hit 1 set 1 del 1\r\n", "details after delete"); is(scalar <$sock>, "END\r\n", "end of details"); print $sock "stats reset\r\n"; is(scalar <$sock>, "RESET\r\n", "stats cleared"); print $sock "stats detail dump\r\n"; is(scalar <$sock>, "END\r\n", "empty stats after clear"); mem_get_is($sock, "foo:123", "fooval"); print $sock "stats detail dump\r\n"; is(scalar <$sock>, "PREFIX foo get 1 hit 1 set 0 del 0\r\n", "details after clear and get"); is(scalar <$sock>, "END\r\n", "end of details"); print $sock "stats detail off\r\n"; is(scalar <$sock>, "OK\r\n", "detail collection turned off"); mem_get_is($sock, "foo:124", undef); mem_get_is($sock, "foo:123", "fooval"); print $sock "stats detail dump\r\n"; is(scalar <$sock>, "PREFIX foo get 1 hit 1 set 0 del 0\r\n", "details after stats turned off"); is(scalar <$sock>, "END\r\n", "end of details"); memcached-1.6.20/t/issue_108.t0000664000175000017500000000126314340006077012604 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 4; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $key = "del_key"; print $sock "add $key 0 0 1\r\nx\r\n"; is (scalar <$sock>, "STORED\r\n", "Added a key"); print $sock "delete $key 0\r\n"; is (scalar <$sock>, "DELETED\r\n", "Properly deleted with 0"); print $sock "add $key 0 0 1\r\nx\r\n"; is (scalar <$sock>, "STORED\r\n", "Added again a key"); print $sock "delete $key 0 noreply\r\n"; # will not reply, but a subsequent add will succeed print $sock "add $key 0 0 1\r\nx\r\n"; is (scalar <$sock>, "STORED\r\n", "Add succeeded after quiet deletion."); memcached-1.6.20/t/issue_183.t0000664000175000017500000000122714340006077012607 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 5; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached("-o no_modern"); my $sock = $server->sock; print $sock "set key 0 0 1\r\n1\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key"); my $s1 = mem_stats($sock); my $r1 = $s1->{"reclaimed"}; is ($r1, "0", "Objects should not be reclaimed"); sleep(2); print $sock "flush_all\r\n"; is (scalar <$sock>, "OK\r\n", "Cache flushed"); print $sock "set key 0 0 1\r\n1\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key"); my $s2 = mem_stats($sock); my $r2 = $s2->{"reclaimed"}; is ($r2, "1", "Objects should be reclaimed"); memcached-1.6.20/t/issue_163.t0000664000175000017500000000206014340006077012601 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 7; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; my $value1 = "A"x66560; my $value2 = "B"x66570; print $sock "set key 0 1 66560\r\n$value1\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key"); my $stats = mem_stats($sock, "slabs"); my $requested = $stats->{"31:mem_requested"}; isnt ($requested, "0", "We should have requested some memory"); sleep(3); print $sock "set key 0 0 66570\r\n$value2\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key"); my $stats = mem_stats($sock, "items"); my $reclaimed = $stats->{"items:31:reclaimed"}; is ($reclaimed, "1", "Objects should be reclaimed"); print $sock "delete key\r\n"; is (scalar <$sock>, "DELETED\r\n", "deleted key"); print $sock "set key 0 0 66560\r\n$value1\r\n"; is (scalar <$sock>, "STORED\r\n", "stored key"); my $stats = mem_stats($sock, "slabs"); my $requested2 = $stats->{"31:mem_requested"}; is ($requested2, $requested, "we've not allocated and freed the same amount"); memcached-1.6.20/t/incrdecr.t0000775000175000017500000000416114340006077012660 00000000000000#!/usr/bin/env perl use strict; use Test::More tests => 23; use FindBin qw($Bin); use lib "$Bin/lib"; use MemcachedTest; my $server = new_memcached(); my $sock = $server->sock; # Bug 21 print $sock "set bug21 0 0 19\r\n9223372036854775807\r\n"; is(scalar <$sock>, "STORED\r\n", "stored text"); print $sock "incr bug21 1\r\n"; is(scalar <$sock>, "9223372036854775808\r\n", "bug21 incr 1"); print $sock "incr bug21 1\r\n"; is(scalar <$sock>, "9223372036854775809\r\n", "bug21 incr 2"); print $sock "decr bug21 1\r\n"; is(scalar <$sock>, "9223372036854775808\r\n", "bug21 decr"); print $sock "set num 0 0 1\r\n1\r\n"; is(scalar <$sock>, "STORED\r\n", "stored num"); mem_get_is($sock, "num", 1, "stored 1"); print $sock "incr num 1\r\n"; is(scalar <$sock>, "2\r\n", "+ 1 = 2"); mem_get_is($sock, "num", 2); print $sock "incr num 8\r\n"; is(scalar <$sock>, "10\r\n", "+ 8 = 10"); mem_get_is($sock, "num", 10); print $sock "decr num 1\r\n"; is(scalar <$sock>, "9\r\n", "- 1 = 9"); print $sock "decr num 9\r\n"; is(scalar <$sock>, "0\r\n", "- 9 = 0"); print $sock "decr num 5\r\n"; is(scalar <$sock>, "0\r\n", "- 5 = 0"); printf $sock "set num 0 0 10\r\n4294967296\r\n"; is(scalar <$sock>, "STORED\r\n", "stored 2**32"); print $sock "incr num 1\r\n"; is(scalar <$sock>, "4294967297\r\n", "4294967296 + 1 = 4294967297"); printf $sock "set num 0 0 %d\r\n18446744073709551615\r\n", length("18446744073709551615"); is(scalar <$sock>, "STORED\r\n", "stored 2**64-1"); print $sock "incr num 1\r\n"; is(scalar <$sock>, "0\r\n", "(2**64 - 1) + 1 = 0"); print $sock "decr bogus 5\r\n"; is(scalar <$sock>, "NOT_FOUND\r\n", "can't decr bogus key"); print $sock "decr incr 5\r\n"; is(scalar <$sock>, "NOT_FOUND\r\n", "can't incr bogus key"); print $sock "set bigincr 0 0 1\r\n0\r\n"; is(scalar <$sock>, "STORED\r\n", "stored bigincr"); print $sock "incr bigincr 18446744073709551610\r\n"; is(scalar <$sock>, "18446744073709551610\r\n"); print $sock "set text 0 0 2\r\nhi\r\n"; is(scalar <$sock>, "STORED\r\n", "stored hi"); print $sock "incr text 1\r\n"; is(scalar <$sock>, "CLIENT_ERROR cannot increment or decrement non-numeric value\r\n", "hi - 1 = 0"); memcached-1.6.20/proxy_await.c0000664000175000017500000004253414427543277013172 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "proxy.h" typedef struct mcp_await_s { int pending; int wait_for; int req_ref; int argtable_ref; // need to hold refs to any potential hash selectors int restable_ref; // table of result objects int coro_ref; // reference to parent coroutine int detail_ref; // reference to detail string. enum mcp_await_e type; bool completed; // have we completed the parent coroutine or not bool logerr; // create log_req entries for error responses mcp_request_t *rq; mc_resp *resp; // the top level mc_resp to fill in (as if we were an iop) } mcp_await_t; // TODO (v2): mcplib_await_gc() // - needs to handle cases where an await is created, but a rare error happens // before it completes and the coroutine is killed. must check and free its // references. // local restable = mcp.await(request, pools, num_wait) // NOTE: need to hold onto the pool objects since those hold backend // references. Here we just keep a reference to the argument table. static int _mcplib_await(lua_State *L, bool logerr) { mcp_request_t *rq = luaL_checkudata(L, 1, "mcp.request"); luaL_checktype(L, 2, LUA_TTABLE); int n = 0; // length of table of pools int wait_for = 0; // 0 means wait for all responses enum mcp_await_e type = AWAIT_GOOD; int detail_ref = 0; lua_pushnil(L); // init table key while (lua_next(L, 2) != 0) { luaL_checkudata(L, -1, "mcp.pool_proxy"); lua_pop(L, 1); // remove value, keep key. n++; } if (n <= 0) { proxy_lua_error(L, "mcp.await arguments must have at least one pool"); } if (lua_isstring(L, 5)) { // pops the detail string. detail_ref = luaL_ref(L, LUA_REGISTRYINDEX); } if (lua_isnumber(L, 4)) { type = lua_tointeger(L, 4); lua_pop(L, 1); switch (type) { case AWAIT_GOOD: case AWAIT_ANY: case AWAIT_OK: case AWAIT_FIRST: case AWAIT_FASTGOOD: case AWAIT_BACKGROUND: break; default: proxy_lua_error(L, "invalid type argument tp mcp.await"); } } if (lua_isnumber(L, 3)) { wait_for = lua_tointeger(L, 3); lua_pop(L, 1); if (wait_for > n) { wait_for = n; } } // FIRST is only looking for one valid request. if (type == AWAIT_FIRST) { wait_for = 1; } // TODO (v2): quickly loop table once and ensure they're all pools? // TODO (v2) in case of newuserdatauv throwing an error, we need to grab // these references after allocating *aw else can leak memory. int argtable_ref = luaL_ref(L, LUA_REGISTRYINDEX); // pops the arg table int req_ref = luaL_ref(L, LUA_REGISTRYINDEX); // pops request object. // stack will be only the await object now // allocate before grabbing references so an error won't cause leaks. mcp_await_t *aw = lua_newuserdatauv(L, sizeof(mcp_await_t), 0); memset(aw, 0, sizeof(mcp_await_t)); aw->wait_for = wait_for; aw->pending = n; aw->argtable_ref = argtable_ref; aw->rq = rq; aw->req_ref = req_ref; aw->detail_ref = detail_ref; aw->type = type; aw->logerr = logerr; P_DEBUG("%s: about to yield [len: %d]\n", __func__, n); lua_pushinteger(L, MCP_YIELD_AWAIT); return lua_yield(L, 2); } // default await, no logging. int mcplib_await(lua_State *L) { return _mcplib_await(L, false); } int mcplib_await_logerrors(lua_State *L) { return _mcplib_await(L, true); } static void mcp_queue_await_io(conn *c, lua_State *Lc, mcp_request_t *rq, int await_ref, bool await_first) { io_queue_t *q = conn_io_queue_get(c, IO_QUEUE_PROXY); mcp_backend_t *be = rq->be; // Then we push a response object, which we'll re-use later. // reserve one uservalue for a lua-supplied response. mcp_resp_t *r = lua_newuserdatauv(Lc, sizeof(mcp_resp_t), 1); memset(r, 0, sizeof(mcp_resp_t)); r->thread = c->thread; assert(r->thread != NULL); gettimeofday(&r->start, NULL); // Set noreply mode. // TODO (v2): the response "inherits" the request's noreply mode, which isn't // strictly correct; we should inherit based on the request that spawned // the coroutine but the structure doesn't allow that yet. // Should also be able to settle this exact mode from the parser so we // don't have to re-branch here. if (rq->pr.noreply) { if (rq->pr.cmd_type == CMD_TYPE_META) { r->mode = RESP_MODE_METAQUIET; for (int x = 2; x < rq->pr.ntokens; x++) { if (rq->request[rq->pr.tokens[x]] == 'q') { rq->request[rq->pr.tokens[x]] = ' '; } } } else { r->mode = RESP_MODE_NOREPLY; rq->request[rq->pr.reqlen - 3] = 'Y'; } } else { r->mode = RESP_MODE_NORMAL; } r->cmd = rq->pr.command; luaL_getmetatable(Lc, "mcp.response"); lua_setmetatable(Lc, -2); io_pending_proxy_t *p = do_cache_alloc(c->thread->io_cache); if (p == NULL) { WSTAT_INCR(c->thread, proxy_conn_oom, 1); proxy_lua_error(Lc, "out of memory allocating from IO cache"); return; } // this is a re-cast structure, so assert that we never outsize it. assert(sizeof(io_pending_t) >= sizeof(io_pending_proxy_t)); memset(p, 0, sizeof(io_pending_proxy_t)); // set up back references. p->io_queue_type = IO_QUEUE_PROXY; p->thread = c->thread; p->c = c; p->resp = NULL; p->client_resp = r; p->flushed = false; p->ascii_multiget = rq->ascii_multiget; p->return_cb = proxy_return_cb; p->finalize_cb = proxy_finalize_cb; // io_p needs to hold onto its own response reference, because we may or // may not include it in the final await() result. p->mcpres_ref = luaL_ref(Lc, LUA_REGISTRYINDEX); // pops mcp.response // avoiding coroutine reference for sub-IO p->coro_ref = 0; p->coro = NULL; // await specific p->is_await = true; p->await_ref = await_ref; p->await_first = await_first; // The direct backend object. await object is holding reference p->backend = be; // See #887 for notes. // TODO (v2): hopefully this can be optimized out. strncpy(r->be_name, be->name, MAX_NAMELEN+1); strncpy(r->be_port, be->port, MAX_PORTLEN+1); mcp_request_attach(Lc, rq, p); // link into the batch chain. p->next = q->stack_ctx; q->stack_ctx = p; P_DEBUG("%s: queued\n", __func__); return; } static void mcp_queue_await_dummy_io(conn *c, lua_State *Lc, int await_ref) { io_queue_t *q = conn_io_queue_get(c, IO_QUEUE_PROXY); io_pending_proxy_t *p = do_cache_alloc(c->thread->io_cache); if (p == NULL) { WSTAT_INCR(c->thread, proxy_conn_oom, 1); proxy_lua_error(Lc, "out of memory allocating from IO cache"); return; } // this is a re-cast structure, so assert that we never outsize it. assert(sizeof(io_pending_t) >= sizeof(io_pending_proxy_t)); memset(p, 0, sizeof(io_pending_proxy_t)); // set up back references. p->io_queue_type = IO_QUEUE_PROXY; p->thread = c->thread; p->c = c; p->resp = NULL; // await specific p->is_await = true; p->await_ref = await_ref; p->await_background = true; p->return_cb = proxy_return_cb; p->finalize_cb = proxy_finalize_cb; // Dummy IO has no backend, and no request attached. // All we need to do is link into the batch chain. p->next = q->stack_ctx; q->stack_ctx = p; P_DEBUG("%s: queued\n", __func__); return; } // TODO (v2): need to get this code running under pcall(). // It looks like a bulk of this code can move into mcplib_await(), // and then here post-yield we can add the conn and coro_ref to the right // places. Else these errors currently crash the daemon. int mcplib_await_run(conn *c, mc_resp *resp, lua_State *L, int coro_ref) { P_DEBUG("%s: start\n", __func__); WSTAT_INCR(c->thread, proxy_await_active, 1); mcp_await_t *aw = lua_touserdata(L, -1); int await_ref = luaL_ref(L, LUA_REGISTRYINDEX); // await is popped. assert(aw != NULL); lua_rawgeti(L, LUA_REGISTRYINDEX, aw->argtable_ref); // -> 1 //dump_stack(L); mcp_request_t *rq = aw->rq; aw->coro_ref = coro_ref; // create result table lua_newtable(L); // -> 2 aw->restable_ref = luaL_ref(L, LUA_REGISTRYINDEX); // pop the result table // prepare the request key const char *key = MCP_PARSER_KEY(rq->pr); size_t len = rq->pr.klen; int n = 0; // TODO (v3) await_first is used as a marker for upping the "wait for // IO's" queue count, which means we need to force it off if we're in // background mode, else we would accidentally wait for a response anyway. // This note is for finding a less convoluted method for this. bool await_first = (aw->type == AWAIT_BACKGROUND) ? false : true; // loop arg table and run each hash selector lua_pushnil(L); // -> 3 while (lua_next(L, 1) != 0) { P_DEBUG("%s: top of loop\n", __func__); // (key, -2), (val, -1) mcp_pool_proxy_t *pp = luaL_testudata(L, -1, "mcp.pool_proxy"); if (pp == NULL) { proxy_lua_error(L, "mcp.await must be supplied with a pool"); } // NOTE: rq->be is only held to help pass the backend into the IOP in // mcp_queue call. Could be a local variable and an argument too. rq->be = mcplib_pool_proxy_call_helper(L, pp, key, len); mcp_queue_await_io(c, L, rq, await_ref, await_first); await_first = false; // pop value, keep key. lua_pop(L, 1); n++; } P_DEBUG("%s: argtable len: %d\n", __func__, n); if (aw->type == AWAIT_BACKGROUND) { mcp_queue_await_dummy_io(c, L, await_ref); aw->pending++; aw->wait_for = 0; } lua_pop(L, 1); // remove table key. aw->resp = resp; // cuddle the current mc_resp to fill later P_DEBUG("%s: end\n", __func__); return 0; } // NOTE: This is unprotected lua/C code. There are no lua-style errors thrown // purposefully as of this writing, but it's still not safe. Either the code // can be restructured to use less lua (which I think is better long term // anyway) or it can be pushed behind a cfunc pcall so we don't crash the // daemon if something bad happens. int mcplib_await_return(io_pending_proxy_t *p) { mcp_await_t *aw; lua_State *L = p->thread->L; // use the main VM coroutine for work bool cleanup = false; bool valid = false; // is response valid to add to the result table. bool completing = false; // TODO (v2): just push the await ptr into *p? lua_rawgeti(L, LUA_REGISTRYINDEX, p->await_ref); aw = lua_touserdata(L, -1); lua_pop(L, 1); // remove AW object from stack assert(aw != NULL); P_DEBUG("%s: start [pending: %d]\n", __func__, aw->pending); //dump_stack(L); aw->pending--; assert(aw->pending >= 0); // Await not yet satisfied. // If wait_for != 0 check for response success // if success and wait_for is *now* 0, we complete. // add successful response to response table // Also, if no wait_for, add response to response table // TODO (v2): for GOOD or OK cases, it might be better to return the // last object as valid if there are otherwise zero valids? // Think we just have to count valids... if (aw->type == AWAIT_BACKGROUND) { // in the background case, we never want to collect responses. if (p->await_background) { // found the dummy IO, complete and return conn to worker. completing = true; } } else if (!aw->completed) { valid = true; // always collect results unless we are completed. if (aw->wait_for > 0) { bool is_good = false; switch (aw->type) { case AWAIT_GOOD: if (p->client_resp->status == MCMC_OK && p->client_resp->resp.code != MCMC_CODE_END) { is_good = true; } break; case AWAIT_ANY: is_good = true; break; case AWAIT_OK: if (p->client_resp->status == MCMC_OK) { is_good = true; } break; case AWAIT_FIRST: if (p->await_first) { is_good = true; } else { // user only wants the first pool's result. valid = false; } break; case AWAIT_FASTGOOD: if (p->client_resp->status == MCMC_OK) { // End early on a hit. if (p->client_resp->resp.code != MCMC_CODE_END) { aw->wait_for = 0; } else { is_good = true; } } break; case AWAIT_BACKGROUND: // In background mode we don't wait for any response. break; } if (is_good) { aw->wait_for--; } if (aw->wait_for == 0) { completing = true; } } } // note that post-completion, we stop gathering responses into the // response table... because it's already been returned. // So "valid" can only be true if also !completed if (aw->pending == 0) { if (!aw->completed) { // were waiting for all responses. completing = true; } cleanup = true; P_DEBUG("%s: pending == 0\n", __func__); } // a valid response to add to the result table. if (valid) { P_DEBUG("%s: valid\n", __func__); lua_rawgeti(L, LUA_REGISTRYINDEX, aw->restable_ref); // -> 1 lua_rawgeti(L, LUA_REGISTRYINDEX, p->mcpres_ref); // -> 2 // couldn't find a table.insert() equivalent; so this is // inserting into the length + 1 position manually. //dump_stack(L); lua_rawseti(L, -2, lua_rawlen(L, 1) + 1); // pops mcpres lua_pop(L, 1); // pops restable } // lose our internal mcpres reference regardless. // also tag the elapsed time into the response. if (p->mcpres_ref) { struct timeval end; gettimeofday(&end, NULL); p->client_resp->elapsed = (end.tv_sec - p->client_resp->start.tv_sec) * 1000000 + (end.tv_usec - p->client_resp->start.tv_usec); // instructed to generate log_req entries for each failed request, // this is useful to do here as these can be asynchronous. // NOTE: this may be a temporary feature. if (aw->logerr && p->client_resp->status != MCMC_OK && aw->completed) { size_t dlen = 0; const char *detail = NULL; logger *l = p->thread->l; // only process logs if someone is listening. if (l->eflags & LOG_PROXYREQS) { lua_rawgeti(L, LUA_REGISTRYINDEX, aw->req_ref); mcp_request_t *rq = lua_touserdata(L, -1); lua_pop(L, 1); // references still held, just clearing stack. mcp_resp_t *rs = p->client_resp; if (aw->detail_ref) { lua_rawgeti(L, LUA_REGISTRYINDEX, aw->detail_ref); detail = luaL_tolstring(L, -1, &dlen); lua_pop(L, 1); } logger_log(l, LOGGER_PROXY_REQ, NULL, rq->pr.request, rq->pr.reqlen, rs->elapsed, rs->resp.type, rs->resp.code, rs->status, detail, dlen, rs->be_name, rs->be_port); } } luaL_unref(L, LUA_REGISTRYINDEX, p->mcpres_ref); } // our await_ref is shared, so we don't need to release it. if (completing) { P_DEBUG("%s: completing\n", __func__); assert(p->c->thread == p->thread); aw->completed = true; // if we haven't completed yet, the connection reference is still // valid. So now we pull it, reduce count, and readd if necessary. // here is also the point where we resume the coroutine. lua_rawgeti(L, LUA_REGISTRYINDEX, aw->coro_ref); lua_State *Lc = lua_tothread(L, -1); lua_rawgeti(Lc, LUA_REGISTRYINDEX, aw->restable_ref); // -> 1 proxy_run_coroutine(Lc, aw->resp, NULL, p->c); luaL_unref(L, LUA_REGISTRYINDEX, aw->coro_ref); luaL_unref(L, LUA_REGISTRYINDEX, aw->restable_ref); io_queue_t *q = conn_io_queue_get(p->c, p->io_queue_type); q->count--; if (q->count == 0) { // call re-add directly since we're already in the worker thread. conn_worker_readd(p->c); } } if (cleanup) { P_DEBUG("%s: cleanup [completed: %d]\n", __func__, aw->completed); luaL_unref(L, LUA_REGISTRYINDEX, aw->argtable_ref); luaL_unref(L, LUA_REGISTRYINDEX, aw->req_ref); luaL_unref(L, LUA_REGISTRYINDEX, p->await_ref); if (aw->detail_ref) { luaL_unref(L, LUA_REGISTRYINDEX, aw->detail_ref); } WSTAT_DECR(p->thread, proxy_await_active, 1); } // Just remove anything we could have left on the primary VM stack lua_settop(L, 0); // always return free this sub-IO object. do_cache_free(p->thread->io_cache, p); return 0; } memcached-1.6.20/queue.h0000664000175000017500000007131314340006077011734 00000000000000// grabbed from https://raw.githubusercontent.com/freebsd/freebsd-src/master/sys/sys/queue.h // on jan 17th, 2021. /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1991, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)queue.h 8.5 (Berkeley) 8/20/94 * $FreeBSD$ */ #ifndef _SYS_QUEUE_H_ #define _SYS_QUEUE_H_ /* * This file defines four types of data structures: singly-linked lists, * singly-linked tail queues, lists and tail queues. * * A singly-linked list is headed by a single forward pointer. The elements * are singly linked for minimum space and pointer manipulation overhead at * the expense of O(n) removal for arbitrary elements. New elements can be * added to the list after an existing element or at the head of the list. * Elements being removed from the head of the list should use the explicit * macro for this purpose for optimum efficiency. A singly-linked list may * only be traversed in the forward direction. Singly-linked lists are ideal * for applications with large datasets and few or no removals or for * implementing a LIFO queue. * * A singly-linked tail queue is headed by a pair of pointers, one to the * head of the list and the other to the tail of the list. The elements are * singly linked for minimum space and pointer manipulation overhead at the * expense of O(n) removal for arbitrary elements. New elements can be added * to the list after an existing element, at the head of the list, or at the * end of the list. Elements being removed from the head of the tail queue * should use the explicit macro for this purpose for optimum efficiency. * A singly-linked tail queue may only be traversed in the forward direction. * Singly-linked tail queues are ideal for applications with large datasets * and few or no removals or for implementing a FIFO queue. * * A list is headed by a single forward pointer (or an array of forward * pointers for a hash table header). The elements are doubly linked * so that an arbitrary element can be removed without a need to * traverse the list. New elements can be added to the list before * or after an existing element or at the head of the list. A list * may be traversed in either direction. * * A tail queue is headed by a pair of pointers, one to the head of the * list and the other to the tail of the list. The elements are doubly * linked so that an arbitrary element can be removed without a need to * traverse the list. New elements can be added to the list before or * after an existing element, at the head of the list, or at the end of * the list. A tail queue may be traversed in either direction. * * For details on the use of these macros, see the queue(3) manual page. * * Below is a summary of implemented functions where: * + means the macro is available * - means the macro is not available * s means the macro is available but is slow (runs in O(n) time) * * SLIST LIST STAILQ TAILQ * _HEAD + + + + * _CLASS_HEAD + + + + * _HEAD_INITIALIZER + + + + * _ENTRY + + + + * _CLASS_ENTRY + + + + * _INIT + + + + * _EMPTY + + + + * _FIRST + + + + * _NEXT + + + + * _PREV - + - + * _LAST - - + + * _LAST_FAST - - - + * _FOREACH + + + + * _FOREACH_FROM + + + + * _FOREACH_SAFE + + + + * _FOREACH_FROM_SAFE + + + + * _FOREACH_REVERSE - - - + * _FOREACH_REVERSE_FROM - - - + * _FOREACH_REVERSE_SAFE - - - + * _FOREACH_REVERSE_FROM_SAFE - - - + * _INSERT_HEAD + + + + * _INSERT_BEFORE - + - + * _INSERT_AFTER + + + + * _INSERT_TAIL - - + + * _CONCAT s s + + * _REMOVE_AFTER + - + - * _REMOVE_HEAD + - + - * _REMOVE s + s + * _SWAP + + + + * */ #ifdef QUEUE_MACRO_DEBUG #warn Use QUEUE_MACRO_DEBUG_TRACE and/or QUEUE_MACRO_DEBUG_TRASH #define QUEUE_MACRO_DEBUG_TRACE #define QUEUE_MACRO_DEBUG_TRASH #endif #ifdef QUEUE_MACRO_DEBUG_TRACE /* Store the last 2 places the queue element or head was altered */ struct qm_trace { unsigned long lastline; unsigned long prevline; const char *lastfile; const char *prevfile; }; #define TRACEBUF struct qm_trace trace; #define TRACEBUF_INITIALIZER { __LINE__, 0, __FILE__, NULL } , #define QMD_TRACE_HEAD(head) do { \ (head)->trace.prevline = (head)->trace.lastline; \ (head)->trace.prevfile = (head)->trace.lastfile; \ (head)->trace.lastline = __LINE__; \ (head)->trace.lastfile = __FILE__; \ } while (0) #define QMD_TRACE_ELEM(elem) do { \ (elem)->trace.prevline = (elem)->trace.lastline; \ (elem)->trace.prevfile = (elem)->trace.lastfile; \ (elem)->trace.lastline = __LINE__; \ (elem)->trace.lastfile = __FILE__; \ } while (0) #else /* !QUEUE_MACRO_DEBUG_TRACE */ #define QMD_TRACE_ELEM(elem) #define QMD_TRACE_HEAD(head) #define TRACEBUF #define TRACEBUF_INITIALIZER #endif /* QUEUE_MACRO_DEBUG_TRACE */ #ifdef QUEUE_MACRO_DEBUG_TRASH #define QMD_SAVELINK(name, link) void **name = (void *)&(link) #define TRASHIT(x) do {(x) = (void *)-1;} while (0) #define QMD_IS_TRASHED(x) ((x) == (void *)(intptr_t)-1) #else /* !QUEUE_MACRO_DEBUG_TRASH */ #define QMD_SAVELINK(name, link) #define TRASHIT(x) #define QMD_IS_TRASHED(x) 0 #endif /* QUEUE_MACRO_DEBUG_TRASH */ #ifdef __cplusplus /* * In C++ there can be structure lists and class lists: */ #define QUEUE_TYPEOF(type) type #else #define QUEUE_TYPEOF(type) struct type #endif /* * Singly-linked List declarations. */ #define SLIST_HEAD(name, type) \ struct name { \ struct type *slh_first; /* first element */ \ } #define SLIST_CLASS_HEAD(name, type) \ struct name { \ class type *slh_first; /* first element */ \ } #define SLIST_HEAD_INITIALIZER(head) \ { NULL } #define SLIST_ENTRY(type) \ struct { \ struct type *sle_next; /* next element */ \ } #define SLIST_CLASS_ENTRY(type) \ struct { \ class type *sle_next; /* next element */ \ } /* * Singly-linked List functions. */ #if (defined(_KERNEL) && defined(INVARIANTS)) #define QMD_SLIST_CHECK_PREVPTR(prevp, elm) do { \ if (*(prevp) != (elm)) \ panic("Bad prevptr *(%p) == %p != %p", \ (prevp), *(prevp), (elm)); \ } while (0) #else #define QMD_SLIST_CHECK_PREVPTR(prevp, elm) #endif #define SLIST_CONCAT(head1, head2, type, field) do { \ QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head1); \ if (curelm == NULL) { \ if ((SLIST_FIRST(head1) = SLIST_FIRST(head2)) != NULL) \ SLIST_INIT(head2); \ } else if (SLIST_FIRST(head2) != NULL) { \ while (SLIST_NEXT(curelm, field) != NULL) \ curelm = SLIST_NEXT(curelm, field); \ SLIST_NEXT(curelm, field) = SLIST_FIRST(head2); \ SLIST_INIT(head2); \ } \ } while (0) #define SLIST_EMPTY(head) ((head)->slh_first == NULL) #define SLIST_FIRST(head) ((head)->slh_first) #define SLIST_FOREACH(var, head, field) \ for ((var) = SLIST_FIRST((head)); \ (var); \ (var) = SLIST_NEXT((var), field)) #define SLIST_FOREACH_FROM(var, head, field) \ for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \ (var); \ (var) = SLIST_NEXT((var), field)) #define SLIST_FOREACH_SAFE(var, head, field, tvar) \ for ((var) = SLIST_FIRST((head)); \ (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ (var) = (tvar)) #define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \ for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \ (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ (var) = (tvar)) #define SLIST_FOREACH_PREVPTR(var, varp, head, field) \ for ((varp) = &SLIST_FIRST((head)); \ ((var) = *(varp)) != NULL; \ (varp) = &SLIST_NEXT((var), field)) #define SLIST_INIT(head) do { \ SLIST_FIRST((head)) = NULL; \ } while (0) #define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \ SLIST_NEXT((slistelm), field) = (elm); \ } while (0) #define SLIST_INSERT_HEAD(head, elm, field) do { \ SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \ SLIST_FIRST((head)) = (elm); \ } while (0) #define SLIST_NEXT(elm, field) ((elm)->field.sle_next) #define SLIST_REMOVE(head, elm, type, field) do { \ QMD_SAVELINK(oldnext, (elm)->field.sle_next); \ if (SLIST_FIRST((head)) == (elm)) { \ SLIST_REMOVE_HEAD((head), field); \ } \ else { \ QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head); \ while (SLIST_NEXT(curelm, field) != (elm)) \ curelm = SLIST_NEXT(curelm, field); \ SLIST_REMOVE_AFTER(curelm, field); \ } \ TRASHIT(*oldnext); \ } while (0) #define SLIST_REMOVE_AFTER(elm, field) do { \ SLIST_NEXT(elm, field) = \ SLIST_NEXT(SLIST_NEXT(elm, field), field); \ } while (0) #define SLIST_REMOVE_HEAD(head, field) do { \ SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \ } while (0) #define SLIST_REMOVE_PREVPTR(prevp, elm, field) do { \ QMD_SLIST_CHECK_PREVPTR(prevp, elm); \ *(prevp) = SLIST_NEXT(elm, field); \ TRASHIT((elm)->field.sle_next); \ } while (0) #define SLIST_SWAP(head1, head2, type) do { \ QUEUE_TYPEOF(type) *swap_first = SLIST_FIRST(head1); \ SLIST_FIRST(head1) = SLIST_FIRST(head2); \ SLIST_FIRST(head2) = swap_first; \ } while (0) /* * Singly-linked Tail queue declarations. */ #define STAILQ_HEAD(name, type) \ struct name { \ struct type *stqh_first;/* first element */ \ struct type **stqh_last;/* addr of last next element */ \ } #define STAILQ_CLASS_HEAD(name, type) \ struct name { \ class type *stqh_first; /* first element */ \ class type **stqh_last; /* addr of last next element */ \ } #define STAILQ_HEAD_INITIALIZER(head) \ { NULL, &(head).stqh_first } #define STAILQ_ENTRY(type) \ struct { \ struct type *stqe_next; /* next element */ \ } #define STAILQ_CLASS_ENTRY(type) \ struct { \ class type *stqe_next; /* next element */ \ } /* * Singly-linked Tail queue functions. */ #define STAILQ_CONCAT(head1, head2) do { \ if (!STAILQ_EMPTY((head2))) { \ *(head1)->stqh_last = (head2)->stqh_first; \ (head1)->stqh_last = (head2)->stqh_last; \ STAILQ_INIT((head2)); \ } \ } while (0) #define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) #define STAILQ_FIRST(head) ((head)->stqh_first) #define STAILQ_FOREACH(var, head, field) \ for((var) = STAILQ_FIRST((head)); \ (var); \ (var) = STAILQ_NEXT((var), field)) #define STAILQ_FOREACH_FROM(var, head, field) \ for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \ (var); \ (var) = STAILQ_NEXT((var), field)) #define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ for ((var) = STAILQ_FIRST((head)); \ (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ (var) = (tvar)) #define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \ (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ (var) = (tvar)) #define STAILQ_INIT(head) do { \ STAILQ_FIRST((head)) = NULL; \ (head)->stqh_last = &STAILQ_FIRST((head)); \ } while (0) #define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \ if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\ (head)->stqh_last = &STAILQ_NEXT((elm), field); \ STAILQ_NEXT((tqelm), field) = (elm); \ } while (0) #define STAILQ_INSERT_HEAD(head, elm, field) do { \ if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \ (head)->stqh_last = &STAILQ_NEXT((elm), field); \ STAILQ_FIRST((head)) = (elm); \ } while (0) #define STAILQ_INSERT_TAIL(head, elm, field) do { \ STAILQ_NEXT((elm), field) = NULL; \ *(head)->stqh_last = (elm); \ (head)->stqh_last = &STAILQ_NEXT((elm), field); \ } while (0) #define STAILQ_LAST(head, type, field) \ (STAILQ_EMPTY((head)) ? NULL : \ __containerof((head)->stqh_last, \ QUEUE_TYPEOF(type), field.stqe_next)) #define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) #define STAILQ_REMOVE(head, elm, type, field) do { \ QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \ if (STAILQ_FIRST((head)) == (elm)) { \ STAILQ_REMOVE_HEAD((head), field); \ } \ else { \ QUEUE_TYPEOF(type) *curelm = STAILQ_FIRST(head); \ while (STAILQ_NEXT(curelm, field) != (elm)) \ curelm = STAILQ_NEXT(curelm, field); \ STAILQ_REMOVE_AFTER(head, curelm, field); \ } \ TRASHIT(*oldnext); \ } while (0) #define STAILQ_REMOVE_AFTER(head, elm, field) do { \ if ((STAILQ_NEXT(elm, field) = \ STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \ (head)->stqh_last = &STAILQ_NEXT((elm), field); \ } while (0) #define STAILQ_REMOVE_HEAD(head, field) do { \ if ((STAILQ_FIRST((head)) = \ STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \ (head)->stqh_last = &STAILQ_FIRST((head)); \ } while (0) #define STAILQ_SWAP(head1, head2, type) do { \ QUEUE_TYPEOF(type) *swap_first = STAILQ_FIRST(head1); \ QUEUE_TYPEOF(type) **swap_last = (head1)->stqh_last; \ STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \ (head1)->stqh_last = (head2)->stqh_last; \ STAILQ_FIRST(head2) = swap_first; \ (head2)->stqh_last = swap_last; \ if (STAILQ_EMPTY(head1)) \ (head1)->stqh_last = &STAILQ_FIRST(head1); \ if (STAILQ_EMPTY(head2)) \ (head2)->stqh_last = &STAILQ_FIRST(head2); \ } while (0) /* * List declarations. */ #define LIST_HEAD(name, type) \ struct name { \ struct type *lh_first; /* first element */ \ } #define LIST_CLASS_HEAD(name, type) \ struct name { \ class type *lh_first; /* first element */ \ } #define LIST_HEAD_INITIALIZER(head) \ { NULL } #define LIST_ENTRY(type) \ struct { \ struct type *le_next; /* next element */ \ struct type **le_prev; /* address of previous next element */ \ } #define LIST_CLASS_ENTRY(type) \ struct { \ class type *le_next; /* next element */ \ class type **le_prev; /* address of previous next element */ \ } /* * List functions. */ #if (defined(_KERNEL) && defined(INVARIANTS)) /* * QMD_LIST_CHECK_HEAD(LIST_HEAD *head, LIST_ENTRY NAME) * * If the list is non-empty, validates that the first element of the list * points back at 'head.' */ #define QMD_LIST_CHECK_HEAD(head, field) do { \ if (LIST_FIRST((head)) != NULL && \ LIST_FIRST((head))->field.le_prev != \ &LIST_FIRST((head))) \ panic("Bad list head %p first->prev != head", (head)); \ } while (0) /* * QMD_LIST_CHECK_NEXT(TYPE *elm, LIST_ENTRY NAME) * * If an element follows 'elm' in the list, validates that the next element * points back at 'elm.' */ #define QMD_LIST_CHECK_NEXT(elm, field) do { \ if (LIST_NEXT((elm), field) != NULL && \ LIST_NEXT((elm), field)->field.le_prev != \ &((elm)->field.le_next)) \ panic("Bad link elm %p next->prev != elm", (elm)); \ } while (0) /* * QMD_LIST_CHECK_PREV(TYPE *elm, LIST_ENTRY NAME) * * Validates that the previous element (or head of the list) points to 'elm.' */ #define QMD_LIST_CHECK_PREV(elm, field) do { \ if (*(elm)->field.le_prev != (elm)) \ panic("Bad link elm %p prev->next != elm", (elm)); \ } while (0) #else #define QMD_LIST_CHECK_HEAD(head, field) #define QMD_LIST_CHECK_NEXT(elm, field) #define QMD_LIST_CHECK_PREV(elm, field) #endif /* (_KERNEL && INVARIANTS) */ #define LIST_CONCAT(head1, head2, type, field) do { \ QUEUE_TYPEOF(type) *curelm = LIST_FIRST(head1); \ if (curelm == NULL) { \ if ((LIST_FIRST(head1) = LIST_FIRST(head2)) != NULL) { \ LIST_FIRST(head2)->field.le_prev = \ &LIST_FIRST((head1)); \ LIST_INIT(head2); \ } \ } else if (LIST_FIRST(head2) != NULL) { \ while (LIST_NEXT(curelm, field) != NULL) \ curelm = LIST_NEXT(curelm, field); \ LIST_NEXT(curelm, field) = LIST_FIRST(head2); \ LIST_FIRST(head2)->field.le_prev = &LIST_NEXT(curelm, field); \ LIST_INIT(head2); \ } \ } while (0) #define LIST_EMPTY(head) ((head)->lh_first == NULL) #define LIST_FIRST(head) ((head)->lh_first) #define LIST_FOREACH(var, head, field) \ for ((var) = LIST_FIRST((head)); \ (var); \ (var) = LIST_NEXT((var), field)) #define LIST_FOREACH_FROM(var, head, field) \ for ((var) = ((var) ? (var) : LIST_FIRST((head))); \ (var); \ (var) = LIST_NEXT((var), field)) #define LIST_FOREACH_SAFE(var, head, field, tvar) \ for ((var) = LIST_FIRST((head)); \ (var) && ((tvar) = LIST_NEXT((var), field), 1); \ (var) = (tvar)) #define LIST_FOREACH_FROM_SAFE(var, head, field, tvar) \ for ((var) = ((var) ? (var) : LIST_FIRST((head))); \ (var) && ((tvar) = LIST_NEXT((var), field), 1); \ (var) = (tvar)) #define LIST_INIT(head) do { \ LIST_FIRST((head)) = NULL; \ } while (0) #define LIST_INSERT_AFTER(listelm, elm, field) do { \ QMD_LIST_CHECK_NEXT(listelm, field); \ if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\ LIST_NEXT((listelm), field)->field.le_prev = \ &LIST_NEXT((elm), field); \ LIST_NEXT((listelm), field) = (elm); \ (elm)->field.le_prev = &LIST_NEXT((listelm), field); \ } while (0) #define LIST_INSERT_BEFORE(listelm, elm, field) do { \ QMD_LIST_CHECK_PREV(listelm, field); \ (elm)->field.le_prev = (listelm)->field.le_prev; \ LIST_NEXT((elm), field) = (listelm); \ *(listelm)->field.le_prev = (elm); \ (listelm)->field.le_prev = &LIST_NEXT((elm), field); \ } while (0) #define LIST_INSERT_HEAD(head, elm, field) do { \ QMD_LIST_CHECK_HEAD((head), field); \ if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \ LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\ LIST_FIRST((head)) = (elm); \ (elm)->field.le_prev = &LIST_FIRST((head)); \ } while (0) #define LIST_NEXT(elm, field) ((elm)->field.le_next) #define LIST_PREV(elm, head, type, field) \ ((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : \ __containerof((elm)->field.le_prev, \ QUEUE_TYPEOF(type), field.le_next)) #define LIST_REMOVE(elm, field) do { \ QMD_SAVELINK(oldnext, (elm)->field.le_next); \ QMD_SAVELINK(oldprev, (elm)->field.le_prev); \ QMD_LIST_CHECK_NEXT(elm, field); \ QMD_LIST_CHECK_PREV(elm, field); \ if (LIST_NEXT((elm), field) != NULL) \ LIST_NEXT((elm), field)->field.le_prev = \ (elm)->field.le_prev; \ *(elm)->field.le_prev = LIST_NEXT((elm), field); \ TRASHIT(*oldnext); \ TRASHIT(*oldprev); \ } while (0) #define LIST_SWAP(head1, head2, type, field) do { \ QUEUE_TYPEOF(type) *swap_tmp = LIST_FIRST(head1); \ LIST_FIRST((head1)) = LIST_FIRST((head2)); \ LIST_FIRST((head2)) = swap_tmp; \ if ((swap_tmp = LIST_FIRST((head1))) != NULL) \ swap_tmp->field.le_prev = &LIST_FIRST((head1)); \ if ((swap_tmp = LIST_FIRST((head2))) != NULL) \ swap_tmp->field.le_prev = &LIST_FIRST((head2)); \ } while (0) /* * Tail queue declarations. */ #define TAILQ_HEAD(name, type) \ struct name { \ struct type *tqh_first; /* first element */ \ struct type **tqh_last; /* addr of last next element */ \ TRACEBUF \ } #define TAILQ_CLASS_HEAD(name, type) \ struct name { \ class type *tqh_first; /* first element */ \ class type **tqh_last; /* addr of last next element */ \ TRACEBUF \ } #define TAILQ_HEAD_INITIALIZER(head) \ { NULL, &(head).tqh_first, TRACEBUF_INITIALIZER } #define TAILQ_ENTRY(type) \ struct { \ struct type *tqe_next; /* next element */ \ struct type **tqe_prev; /* address of previous next element */ \ TRACEBUF \ } #define TAILQ_CLASS_ENTRY(type) \ struct { \ class type *tqe_next; /* next element */ \ class type **tqe_prev; /* address of previous next element */ \ TRACEBUF \ } /* * Tail queue functions. */ #if (defined(_KERNEL) && defined(INVARIANTS)) /* * QMD_TAILQ_CHECK_HEAD(TAILQ_HEAD *head, TAILQ_ENTRY NAME) * * If the tailq is non-empty, validates that the first element of the tailq * points back at 'head.' */ #define QMD_TAILQ_CHECK_HEAD(head, field) do { \ if (!TAILQ_EMPTY(head) && \ TAILQ_FIRST((head))->field.tqe_prev != \ &TAILQ_FIRST((head))) \ panic("Bad tailq head %p first->prev != head", (head)); \ } while (0) /* * QMD_TAILQ_CHECK_TAIL(TAILQ_HEAD *head, TAILQ_ENTRY NAME) * * Validates that the tail of the tailq is a pointer to pointer to NULL. */ #define QMD_TAILQ_CHECK_TAIL(head, field) do { \ if (*(head)->tqh_last != NULL) \ panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); \ } while (0) /* * QMD_TAILQ_CHECK_NEXT(TYPE *elm, TAILQ_ENTRY NAME) * * If an element follows 'elm' in the tailq, validates that the next element * points back at 'elm.' */ #define QMD_TAILQ_CHECK_NEXT(elm, field) do { \ if (TAILQ_NEXT((elm), field) != NULL && \ TAILQ_NEXT((elm), field)->field.tqe_prev != \ &((elm)->field.tqe_next)) \ panic("Bad link elm %p next->prev != elm", (elm)); \ } while (0) /* * QMD_TAILQ_CHECK_PREV(TYPE *elm, TAILQ_ENTRY NAME) * * Validates that the previous element (or head of the tailq) points to 'elm.' */ #define QMD_TAILQ_CHECK_PREV(elm, field) do { \ if (*(elm)->field.tqe_prev != (elm)) \ panic("Bad link elm %p prev->next != elm", (elm)); \ } while (0) #else #define QMD_TAILQ_CHECK_HEAD(head, field) #define QMD_TAILQ_CHECK_TAIL(head, headname) #define QMD_TAILQ_CHECK_NEXT(elm, field) #define QMD_TAILQ_CHECK_PREV(elm, field) #endif /* (_KERNEL && INVARIANTS) */ #define TAILQ_CONCAT(head1, head2, field) do { \ if (!TAILQ_EMPTY(head2)) { \ *(head1)->tqh_last = (head2)->tqh_first; \ (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \ (head1)->tqh_last = (head2)->tqh_last; \ TAILQ_INIT((head2)); \ QMD_TRACE_HEAD(head1); \ QMD_TRACE_HEAD(head2); \ } \ } while (0) #define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) #define TAILQ_FIRST(head) ((head)->tqh_first) #define TAILQ_FOREACH(var, head, field) \ for ((var) = TAILQ_FIRST((head)); \ (var); \ (var) = TAILQ_NEXT((var), field)) #define TAILQ_FOREACH_FROM(var, head, field) \ for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \ (var); \ (var) = TAILQ_NEXT((var), field)) #define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ for ((var) = TAILQ_FIRST((head)); \ (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ (var) = (tvar)) #define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \ (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ (var) = (tvar)) #define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ for ((var) = TAILQ_LAST((head), headname); \ (var); \ (var) = TAILQ_PREV((var), headname, field)) #define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \ for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \ (var); \ (var) = TAILQ_PREV((var), headname, field)) #define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ for ((var) = TAILQ_LAST((head), headname); \ (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \ (var) = (tvar)) #define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) \ for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \ (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \ (var) = (tvar)) #define TAILQ_INIT(head) do { \ TAILQ_FIRST((head)) = NULL; \ (head)->tqh_last = &TAILQ_FIRST((head)); \ QMD_TRACE_HEAD(head); \ } while (0) #define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ QMD_TAILQ_CHECK_NEXT(listelm, field); \ if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\ TAILQ_NEXT((elm), field)->field.tqe_prev = \ &TAILQ_NEXT((elm), field); \ else { \ (head)->tqh_last = &TAILQ_NEXT((elm), field); \ QMD_TRACE_HEAD(head); \ } \ TAILQ_NEXT((listelm), field) = (elm); \ (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \ QMD_TRACE_ELEM(&(elm)->field); \ QMD_TRACE_ELEM(&(listelm)->field); \ } while (0) #define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ QMD_TAILQ_CHECK_PREV(listelm, field); \ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ TAILQ_NEXT((elm), field) = (listelm); \ *(listelm)->field.tqe_prev = (elm); \ (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \ QMD_TRACE_ELEM(&(elm)->field); \ QMD_TRACE_ELEM(&(listelm)->field); \ } while (0) #define TAILQ_INSERT_HEAD(head, elm, field) do { \ QMD_TAILQ_CHECK_HEAD(head, field); \ if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \ TAILQ_FIRST((head))->field.tqe_prev = \ &TAILQ_NEXT((elm), field); \ else \ (head)->tqh_last = &TAILQ_NEXT((elm), field); \ TAILQ_FIRST((head)) = (elm); \ (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \ QMD_TRACE_HEAD(head); \ QMD_TRACE_ELEM(&(elm)->field); \ } while (0) #define TAILQ_INSERT_TAIL(head, elm, field) do { \ QMD_TAILQ_CHECK_TAIL(head, field); \ TAILQ_NEXT((elm), field) = NULL; \ (elm)->field.tqe_prev = (head)->tqh_last; \ *(head)->tqh_last = (elm); \ (head)->tqh_last = &TAILQ_NEXT((elm), field); \ QMD_TRACE_HEAD(head); \ QMD_TRACE_ELEM(&(elm)->field); \ } while (0) #define TAILQ_LAST(head, headname) \ (*(((struct headname *)((head)->tqh_last))->tqh_last)) /* * The FAST function is fast in that it causes no data access other * then the access to the head. The standard LAST function above * will cause a data access of both the element you want and * the previous element. FAST is very useful for instances when * you may want to prefetch the last data element. */ #define TAILQ_LAST_FAST(head, type, field) \ (TAILQ_EMPTY(head) ? NULL : __containerof((head)->tqh_last, QUEUE_TYPEOF(type), field.tqe_next)) #define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) #define TAILQ_PREV(elm, headname, field) \ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) #define TAILQ_PREV_FAST(elm, head, type, field) \ ((elm)->field.tqe_prev == &(head)->tqh_first ? NULL : \ __containerof((elm)->field.tqe_prev, QUEUE_TYPEOF(type), field.tqe_next)) #define TAILQ_REMOVE(head, elm, field) do { \ QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \ QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \ QMD_TAILQ_CHECK_NEXT(elm, field); \ QMD_TAILQ_CHECK_PREV(elm, field); \ if ((TAILQ_NEXT((elm), field)) != NULL) \ TAILQ_NEXT((elm), field)->field.tqe_prev = \ (elm)->field.tqe_prev; \ else { \ (head)->tqh_last = (elm)->field.tqe_prev; \ QMD_TRACE_HEAD(head); \ } \ *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \ TRASHIT(*oldnext); \ TRASHIT(*oldprev); \ QMD_TRACE_ELEM(&(elm)->field); \ } while (0) #define TAILQ_SWAP(head1, head2, type, field) do { \ QUEUE_TYPEOF(type) *swap_first = (head1)->tqh_first; \ QUEUE_TYPEOF(type) **swap_last = (head1)->tqh_last; \ (head1)->tqh_first = (head2)->tqh_first; \ (head1)->tqh_last = (head2)->tqh_last; \ (head2)->tqh_first = swap_first; \ (head2)->tqh_last = swap_last; \ if ((swap_first = (head1)->tqh_first) != NULL) \ swap_first->field.tqe_prev = &(head1)->tqh_first; \ else \ (head1)->tqh_last = &(head1)->tqh_first; \ if ((swap_first = (head2)->tqh_first) != NULL) \ swap_first->field.tqe_prev = &(head2)->tqh_first; \ else \ (head2)->tqh_last = &(head2)->tqh_first; \ } while (0) #endif /* !_SYS_QUEUE_H_ */ memcached-1.6.20/items.h0000664000175000017500000000602314403667314011734 00000000000000#define HOT_LRU 0 #define WARM_LRU 64 #define COLD_LRU 128 #define TEMP_LRU 192 #define CLEAR_LRU(id) (id & ~(3<<6)) #define GET_LRU(id) (id & (3<<6)) /* See items.c */ uint64_t get_cas_id(void); void set_cas_id(uint64_t new_cas); /*@null@*/ item *do_item_alloc(const char *key, const size_t nkey, const unsigned int flags, const rel_time_t exptime, const int nbytes); item_chunk *do_item_alloc_chunk(item_chunk *ch, const size_t bytes_remain); item *do_item_alloc_pull(const size_t ntotal, const unsigned int id); void item_free(item *it); bool item_size_ok(const size_t nkey, const int flags, const int nbytes); int do_item_link(item *it, const uint32_t hv); /** may fail if transgresses limits */ void do_item_unlink(item *it, const uint32_t hv); void do_item_unlink_nolock(item *it, const uint32_t hv); void do_item_remove(item *it); void do_item_update(item *it); /** update LRU time to current and reposition */ void do_item_update_nolock(item *it); int do_item_replace(item *it, item *new_it, const uint32_t hv); void do_item_link_fixup(item *it); int item_is_flushed(item *it); unsigned int do_get_lru_size(uint32_t id); void do_item_linktail_q(item *it); void do_item_unlinktail_q(item *it); item *do_item_crawl_q(item *it); void *item_lru_bump_buf_create(void); #define LRU_PULL_EVICT 1 #define LRU_PULL_CRAWL_BLOCKS 2 #define LRU_PULL_RETURN_ITEM 4 /* fill info struct if available */ struct lru_pull_tail_return { item *it; uint32_t hv; }; int lru_pull_tail(const int orig_id, const int cur_lru, const uint64_t total_bytes, const uint8_t flags, const rel_time_t max_age, struct lru_pull_tail_return *ret_it); /*@null@*/ char *item_cachedump(const unsigned int slabs_clsid, const unsigned int limit, unsigned int *bytes); void item_stats(ADD_STAT add_stats, void *c); void do_item_stats_add_crawl(const int i, const uint64_t reclaimed, const uint64_t unfetched, const uint64_t checked); void item_stats_totals(ADD_STAT add_stats, void *c); /*@null@*/ void item_stats_sizes(ADD_STAT add_stats, void *c); void item_stats_sizes_init(void); void item_stats_sizes_enable(ADD_STAT add_stats, void *c); void item_stats_sizes_disable(ADD_STAT add_stats, void *c); void item_stats_sizes_add(item *it); void item_stats_sizes_remove(item *it); bool item_stats_sizes_status(void); /* stats getter for slab automover */ typedef struct { int64_t evicted; int64_t outofmemory; uint32_t age; } item_stats_automove; void fill_item_stats_automove(item_stats_automove *am); item *do_item_get(const char *key, const size_t nkey, const uint32_t hv, LIBEVENT_THREAD *t, const bool do_update); item *do_item_touch(const char *key, const size_t nkey, uint32_t exptime, const uint32_t hv, LIBEVENT_THREAD *t); void do_item_bump(LIBEVENT_THREAD *t, item *it, const uint32_t hv); void item_stats_reset(void); extern pthread_mutex_t lru_locks[POWER_LARGEST]; int start_lru_maintainer_thread(void *arg); int stop_lru_maintainer_thread(void); void lru_maintainer_pause(void); void lru_maintainer_resume(void); void *lru_bump_buf_create(void); memcached-1.6.20/stats_prefix.h0000664000175000017500000000347314204760331013324 00000000000000#ifndef STATS_PREFIX_H #define STATS_PREFIX_H /* The stats prefix subsystem stores detailed statistics for each key prefix. * Simple statistics like total number of GETS are stored by the Stats * subsystem defined elsewhere. * * Suppose the prefix delimiter is ":", then "user:123" and "user:456" both * have the same prefix "user". */ /* Initialize the stats prefix subsystem. Should be called once before other * functions are called. The global hash initialization should be done before * using this subsystem. */ void stats_prefix_init(char prefix_delimiter); /* Clear previously collected stats. Requires you to have the acquired * the STATS_LOCK() first. */ void stats_prefix_clear(void); /* Record a GET for a key */ void stats_prefix_record_get(const char *key, const size_t nkey, const bool is_hit); /* Record a DELETE for a key */ void stats_prefix_record_delete(const char *key, const size_t nkey); /* Record a SET for a key */ void stats_prefix_record_set(const char *key, const size_t nkey); /* Return the collected stats in a textual for suitable for writing to a client. * The size of the output text is stored in the length parameter. * Returns NULL on error */ char *stats_prefix_dump(int *length); /* Visible for testing */ #define PREFIX_HASH_SIZE 256 typedef struct _prefix_stats PREFIX_STATS; struct _prefix_stats { char *prefix; size_t prefix_len; uint64_t num_gets; uint64_t num_sets; uint64_t num_deletes; uint64_t num_hits; PREFIX_STATS *next; }; /* Return the PREFIX_STATS structure for the specified key, creating it if * it does not already exist. Returns NULL if the key does not contain * prefix delimiter, or if there was an error. Requires you to have acquired * STATS_LOCK() first. */ PREFIX_STATS *stats_prefix_find(const char *key, const size_t nkey); #endif memcached-1.6.20/proxy_network.c0000664000175000017500000011774114427543277013561 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ // Functions related to the backend handler thread. #include "proxy.h" enum proxy_be_failures { P_BE_FAIL_TIMEOUT = 0, P_BE_FAIL_DISCONNECTED, P_BE_FAIL_CONNECTING, P_BE_FAIL_CONNTIMEOUT, P_BE_FAIL_READVALIDATE, P_BE_FAIL_BADVALIDATE, P_BE_FAIL_WRITING, P_BE_FAIL_READING, P_BE_FAIL_PARSING, P_BE_FAIL_CLOSED, P_BE_FAIL_UNHANDLEDRES, P_BE_FAIL_OOM, P_BE_FAIL_ENDSYNC, P_BE_FAIL_TRAILINGDATA, P_BE_FAIL_INVALIDPROTOCOL, }; const char *proxy_be_failure_text[] = { [P_BE_FAIL_TIMEOUT] = "timeout", [P_BE_FAIL_DISCONNECTED] = "disconnected", [P_BE_FAIL_CONNECTING] = "connecting", [P_BE_FAIL_CONNTIMEOUT] = "conntimeout", [P_BE_FAIL_READVALIDATE] = "readvalidate", [P_BE_FAIL_BADVALIDATE] = "badvalidate", [P_BE_FAIL_WRITING] = "writing", [P_BE_FAIL_READING] = "reading", [P_BE_FAIL_PARSING] = "parsing", [P_BE_FAIL_CLOSED] = "closedsock", [P_BE_FAIL_UNHANDLEDRES] = "unhandledres", [P_BE_FAIL_OOM] = "outofmemory", [P_BE_FAIL_ENDSYNC] = "missingend", [P_BE_FAIL_TRAILINGDATA] = "trailingdata", [P_BE_FAIL_INVALIDPROTOCOL] = "invalidprotocol", NULL }; static void proxy_backend_handler(const int fd, const short which, void *arg); static void proxy_beconn_handler(const int fd, const short which, void *arg); static void proxy_event_handler(evutil_socket_t fd, short which, void *arg); static void proxy_event_beconn(evutil_socket_t fd, short which, void *arg); static int _prep_pending_write(mcp_backend_t *be); static void _post_pending_write(mcp_backend_t *be, ssize_t sent); static int _flush_pending_write(mcp_backend_t *be); static void _cleanup_backend(mcp_backend_t *be); static int _reset_bad_backend(mcp_backend_t *be, enum proxy_be_failures err); static void _backend_failed(mcp_backend_t *be); static void _set_main_event(mcp_backend_t *be, struct event_base *base, int flags, struct timeval *t, event_callback_fn callback); static void _stop_main_event(mcp_backend_t *be); static void _start_write_event(mcp_backend_t *be); static void _stop_write_event(mcp_backend_t *be); static void _start_timeout_event(mcp_backend_t *be); static void _stop_timeout_event(mcp_backend_t *be); static int proxy_backend_drive_machine(mcp_backend_t *be); /* Helper routines common to io_uring and libevent modes */ // TODO (v3): doing an inline syscall here, not ideal for uring mode. // leaving for now since this should be extremely uncommon. static int _beconn_send_validate(mcp_backend_t *be) { const char *str = "version\r\n"; const ssize_t len = strlen(str); ssize_t res = write(mcmc_fd(be->client), str, len); if (res == -1) { return -1; } // I'm making an opinionated statement that we should be able to write // "version\r\n" into a fresh socket without hitting EAGAIN. if (res < len) { return -1; } return 1; } // FIXME: make _backend_failed conditionally use _ur() so we can have one call // in the code and reuse more code like this. static int _proxy_beconn_checkconnect(mcp_backend_t *be) { int err = 0; // We were connecting, now ensure we're properly connected. if (mcmc_check_nonblock_connect(be->client, &err) != MCMC_OK) { P_DEBUG("%s: backend failed to connect (%s:%s)\n", __func__, be->name, be->port); // kick the bad backend, clear the queue, retry later. // FIXME (v2): if a connect fails, anything currently in the queue // should be safe to hold up until their timeout. _reset_bad_backend(be, P_BE_FAIL_CONNECTING); _backend_failed(be); return -1; } P_DEBUG("%s: backend connected (%s:%s)\n", __func__, be->name, be->port); be->connecting = false; be->state = mcp_backend_read; be->bad = false; be->failed_count = 0; be->validating = true; // TODO: make validation optional. if (_beconn_send_validate(be) == -1) { _reset_bad_backend(be, P_BE_FAIL_BADVALIDATE); _backend_failed(be); return -1; } else { // buffer should be empty during validation stage. assert(be->rbufused == 0); return 0; } } static int _proxy_event_handler_dequeue(proxy_event_thread_t *t) { io_head_t head; STAILQ_INIT(&head); STAILQ_INIT(&t->be_head); // Pull the entire stack of inbound into local queue. pthread_mutex_lock(&t->mutex); STAILQ_CONCAT(&head, &t->io_head_in); pthread_mutex_unlock(&t->mutex); int io_count = 0; int be_count = 0; while (!STAILQ_EMPTY(&head)) { io_pending_proxy_t *io = STAILQ_FIRST(&head); io->flushed = false; // _no_ mutex on backends. they are owned by the event thread. STAILQ_REMOVE_HEAD(&head, io_next); // paranoia about moving items between lists. io->io_next.stqe_next = NULL; mcp_backend_t *be = io->backend; // So the backend can retrieve its event base. if (be->bad) { P_DEBUG("%s: fast failing request to bad backend\n", __func__); io->client_resp->status = MCMC_ERR; return_io_pending((io_pending_t *)io); continue; } STAILQ_INSERT_TAIL(&be->io_head, io, io_next); be->depth++; io_count++; if (!be->stacked) { be->stacked = true; // more paranoia about be_next not being overwritten be->be_next.stqe_next = NULL; STAILQ_INSERT_TAIL(&t->be_head, be, be_next); be_count++; } } //P_DEBUG("%s: io/be counts for syscalls [%d/%d]\n", __func__, io_count, be_count); return io_count; } static void _cleanup_backend(mcp_backend_t *be) { // remove any pending events. int pending = event_pending(&be->main_event, EV_READ|EV_WRITE|EV_TIMEOUT, NULL); if ((pending & (EV_READ|EV_WRITE|EV_TIMEOUT)) != 0) { event_del(&be->main_event); // an error to call event_del() without event. } pending = event_pending(&be->write_event, EV_READ|EV_WRITE|EV_TIMEOUT, NULL); if ((pending & (EV_READ|EV_WRITE|EV_TIMEOUT)) != 0) { event_del(&be->write_event); // an error to call event_del() without event. } pending = event_pending(&be->timeout_event, EV_TIMEOUT, NULL); if ((pending & (EV_TIMEOUT)) != 0) { event_del(&be->timeout_event); // an error to call event_del() without event. } // - assert on empty queue assert(STAILQ_EMPTY(&be->io_head)); mcmc_disconnect(be->client); // - free be->client free(be->client); // - free be->rbuf free(be->rbuf); // - free *be free(be); } // event handler for injecting backends for processing // currently just for initiating connections the first time. static void proxy_event_beconn(evutil_socket_t fd, short which, void *arg) { proxy_event_thread_t *t = arg; #ifdef USE_EVENTFD uint64_t u; if (read(fd, &u, sizeof(uint64_t)) != sizeof(uint64_t)) { // Temporary error or wasn't actually ready to read somehow. return; } #else char buf[1]; if (read(fd, buf, 1) != 1) { P_DEBUG("%s: pipe read failed\n", __func__); return; } #endif beconn_head_t head; STAILQ_INIT(&head); pthread_mutex_lock(&t->mutex); STAILQ_CONCAT(&head, &t->beconn_head_in); pthread_mutex_unlock(&t->mutex); // Think we should reuse this code path for manually instructing backends // to disable/etc but not coding for that generically. We just need to // check the state of the backend when it reaches here or some flags at // least. // FIXME: another ->stacked flag? // Either that or remove the STAILQ code and just using an array of // ptr's. mcp_backend_t *be = NULL; // be can be freed by the loop, so can't use STAILQ_FOREACH. while (!STAILQ_EMPTY(&head)) { be = STAILQ_FIRST(&head); STAILQ_REMOVE_HEAD(&head, beconn_next); if (be->transferred) { // If this object was already transferred here, we're being // signalled to clean it up and free. _cleanup_backend(be); } else { be->transferred = true; // assign the initial events to the backend, so we don't have to // constantly check if they were initialized yet elsewhere. // note these events will not fire until event_add() is called. int status = mcmc_connect(be->client, be->name, be->port, be->connect_flags); event_assign(&be->main_event, be->event_thread->base, mcmc_fd(be->client), EV_WRITE|EV_TIMEOUT, proxy_beconn_handler, be); event_assign(&be->write_event, be->event_thread->base, mcmc_fd(be->client), EV_WRITE|EV_TIMEOUT, proxy_backend_handler, be); event_assign(&be->timeout_event, be->event_thread->base, -1, EV_TIMEOUT, proxy_backend_handler, be); if (status == MCMC_CONNECTING || status == MCMC_CONNECTED) { // if we're already connected for some reason, still push it // through the connection handler to keep the code unified. It // will auto-wake because the socket is writeable. be->connecting = true; be->can_write = false; // kick off the event we intialized above. event_add(&be->main_event, &be->tunables.connect); } else { _reset_bad_backend(be, P_BE_FAIL_CONNECTING); _backend_failed(be); } } } } void proxy_run_backend_queue(be_head_t *head) { mcp_backend_t *be; STAILQ_FOREACH(be, head, be_next) { be->stacked = false; int flags = 0; if (be->bad) { // flush queue if backend is still bad. // TODO: duplicated from _reset_bad_backend() io_pending_proxy_t *io = NULL; while (!STAILQ_EMPTY(&be->io_head)) { io = STAILQ_FIRST(&be->io_head); STAILQ_REMOVE_HEAD(&be->io_head, io_next); io->client_resp->status = MCMC_ERR; be->depth--; return_io_pending((io_pending_t *)io); } } else if (be->connecting || be->validating) { P_DEBUG("%s: deferring IO pending connecting (%s:%s)\n", __func__, be->name, be->port); } else { flags = _flush_pending_write(be); if (flags == -1) { _reset_bad_backend(be, P_BE_FAIL_WRITING); _backend_failed(be); } else if (flags & EV_WRITE) { // only get here because we need to kick off the write handler _start_write_event(be); } if (be->pending_read) { _start_timeout_event(be); } } } } // event handler for executing backend requests static void proxy_event_handler(evutil_socket_t fd, short which, void *arg) { proxy_event_thread_t *t = arg; #ifdef USE_EVENTFD uint64_t u; if (read(fd, &u, sizeof(uint64_t)) != sizeof(uint64_t)) { // Temporary error or wasn't actually ready to read somehow. return; } #else char buf[1]; // TODO (v2): This is a lot more fatal than it should be. can it fail? can // it blow up the server? // TODO (v2): a cross-platform method of speeding this up would be nice. With // event fds we can queue N events and wakeup once here. // If we're pulling one byte out of the pipe at a time here it'll just // wake us up too often. // If the pipe is O_NONBLOCK then maybe just a larger read would work? if (read(fd, buf, 1) != 1) { P_DEBUG("%s: pipe read failed\n", __func__); return; } #endif if (_proxy_event_handler_dequeue(t) == 0) { //P_DEBUG("%s: no IO's to complete\n", __func__); return; } // Re-walk each backend and check set event as required. proxy_run_backend_queue(&t->be_head); } void *proxy_event_thread(void *arg) { proxy_event_thread_t *t = arg; logger_create(); // TODO (v2): add logger ptr to structure event_base_loop(t->base, 0); event_base_free(t->base); // TODO (v2): join bt threads, free array. return NULL; } static void _set_main_event(mcp_backend_t *be, struct event_base *base, int flags, struct timeval *t, event_callback_fn callback) { int pending = event_pending(&be->main_event, EV_READ|EV_WRITE, NULL); if ((pending & (EV_READ|EV_WRITE)) != 0) { event_del(&be->main_event); // replace existing event. } event_assign(&be->main_event, base, mcmc_fd(be->client), flags, callback, be); event_add(&be->main_event, t); } static void _stop_main_event(mcp_backend_t *be) { int pending = event_pending(&be->main_event, EV_READ|EV_WRITE, NULL); if ((pending & (EV_READ|EV_WRITE|EV_TIMEOUT)) == 0) { return; } event_del(&be->write_event); } static void _start_write_event(mcp_backend_t *be) { int pending = event_pending(&be->main_event, EV_WRITE, NULL); if ((pending & (EV_WRITE|EV_TIMEOUT)) != 0) { return; } // FIXME: wasn't there a write timeout? event_add(&be->write_event, &be->tunables.read); } static void _stop_write_event(mcp_backend_t *be) { int pending = event_pending(&be->main_event, EV_WRITE, NULL); if ((pending & (EV_WRITE|EV_TIMEOUT)) == 0) { return; } event_del(&be->write_event); } // handle the read timeouts with a side event, so we can stick with a // persistent listener (optimization + catch disconnects faster) static void _start_timeout_event(mcp_backend_t *be) { int pending = event_pending(&be->timeout_event, EV_TIMEOUT, NULL); if ((pending & (EV_TIMEOUT)) != 0) { return; } event_add(&be->timeout_event, &be->tunables.read); } static void _stop_timeout_event(mcp_backend_t *be) { int pending = event_pending(&be->timeout_event, EV_TIMEOUT, NULL); if ((pending & (EV_TIMEOUT)) == 0) { return; } event_del(&be->timeout_event); } static void _drive_machine_next(mcp_backend_t *be, io_pending_proxy_t *p) { struct timeval end; // set the head here. when we break the head will be correct. STAILQ_REMOVE_HEAD(&be->io_head, io_next); be->depth--; be->pending_read--; // stamp the elapsed time into the response object. gettimeofday(&end, NULL); p->client_resp->elapsed = (end.tv_sec - p->client_resp->start.tv_sec) * 1000000 + (end.tv_usec - p->client_resp->start.tv_usec); // have to do the q->count-- and == 0 and redispatch_conn() // stuff here. The moment we call return_io here we // don't own *p anymore. return_io_pending((io_pending_t *)p); be->state = mcp_backend_read; } // NOTES: // - mcp_backend_read: grab req_stack_head, do things // read -> next, want_read -> next | read_end, etc. static int proxy_backend_drive_machine(mcp_backend_t *be) { bool stop = false; io_pending_proxy_t *p = NULL; int flags = 0; p = STAILQ_FIRST(&be->io_head); if (p == NULL) { // got a read event, but nothing was queued. // probably means a disconnect event. // TODO (v2): could probably confirm this by attempting to read the // socket, getsockopt, or something else simply for logging or // statistical purposes. // In this case we know it's going to be a close so error. flags = P_BE_FAIL_CLOSED; P_DEBUG("%s: read event but nothing in IO queue\n", __func__); return flags; } while (!stop) { mcp_resp_t *r; switch(be->state) { case mcp_backend_read: assert(p != NULL); // FIXME: remove the _read state? be->state = mcp_backend_parse; break; case mcp_backend_parse: r = p->client_resp; r->status = mcmc_parse_buf(be->client, be->rbuf, be->rbufused, &r->resp); // Quick check if we need more data. if (r->resp.code == MCMC_WANT_READ) { return 0; } // we actually don't care about anything but the value length // TODO (v2): if vlen != vlen_read, pull an item and copy the data. int extra_space = 0; // if all goes well, move to the next request. be->state = mcp_backend_next; switch (r->resp.type) { case MCMC_RESP_GET: // We're in GET mode. we only support one key per // GET in the proxy backends, so we need to later check // for an END. extra_space = ENDLEN; be->state = mcp_backend_read_end; break; case MCMC_RESP_END: // this is a MISS from a GET request // or final handler from a STAT request. assert(r->resp.vlen == 0); if (p->ascii_multiget) { // Ascii multiget hack mode; consume END's be->rbufused -= r->resp.reslen; if (be->rbufused > 0) { memmove(be->rbuf, be->rbuf+r->resp.reslen, be->rbufused); } be->state = mcp_backend_next; continue; } break; case MCMC_RESP_META: // we can handle meta responses easily since they're self // contained. break; case MCMC_RESP_GENERIC: case MCMC_RESP_NUMERIC: break; case MCMC_RESP_ERRMSG: // received an error message if (r->resp.code != MCMC_CODE_SERVER_ERROR) { // Non server errors are protocol errors; can't trust // the connection anymore. be->state = mcp_backend_next_close; } break; case MCMC_RESP_FAIL: P_DEBUG("%s: mcmc_read failed [%d]\n", __func__, r->status); flags = P_BE_FAIL_PARSING; stop = true; break; // TODO (v2): No-op response? default: P_DEBUG("%s: Unhandled response from backend: %d\n", __func__, r->resp.type); // unhandled :( flags = P_BE_FAIL_UNHANDLEDRES; stop = true; break; } // r->resp.reslen + r->resp.vlen is the total length of the response. // TODO (v2): need to associate a buffer with this response... // for now we simply malloc, but reusable buffers should be used r->blen = r->resp.reslen + r->resp.vlen; { bool oom = proxy_bufmem_checkadd(r->thread, r->blen + extra_space); if (oom) { flags = P_BE_FAIL_OOM; // need to zero out blen so we don't over-decrement later r->blen = 0; stop = true; break; } } r->buf = malloc(r->blen + extra_space); if (r->buf == NULL) { // Enforce accounting. pthread_mutex_lock(&r->thread->proxy_limit_lock); r->thread->proxy_buffer_memory_used -= r->blen + extra_space; pthread_mutex_unlock(&r->thread->proxy_limit_lock); flags = P_BE_FAIL_OOM; r->blen = 0; stop = true; break; } P_DEBUG("%s: r->status: %d, r->bread: %d, r->vlen: %lu\n", __func__, r->status, r->bread, r->resp.vlen); if (r->resp.vlen != r->resp.vlen_read) { // shouldn't be possible to have excess in buffer // if we're dealing with a partial value. assert(be->rbufused == r->resp.reslen+r->resp.vlen_read); P_DEBUG("%s: got a short read, moving to want_read\n", __func__); // copy the partial and advance mcmc's buffer digestion. memcpy(r->buf, be->rbuf, r->resp.reslen + r->resp.vlen_read); r->bread = r->resp.reslen + r->resp.vlen_read; be->rbufused = 0; be->state = mcp_backend_want_read; flags = 0; stop = true; break; } else { // mcmc's already counted the value as read if it fit in // the original buffer... memcpy(r->buf, be->rbuf, r->resp.reslen+r->resp.vlen_read); } // had a response, advance the buffer. be->rbufused -= r->resp.reslen + r->resp.vlen_read; if (be->rbufused > 0) { memmove(be->rbuf, be->rbuf+r->resp.reslen+r->resp.vlen_read, be->rbufused); } break; case mcp_backend_read_end: r = p->client_resp; // we need to ensure the next data in the stream is "END\r\n" // if not, the stack is desynced and we lose it. if (be->rbufused >= ENDLEN) { if (memcmp(be->rbuf, ENDSTR, ENDLEN) != 0) { flags = P_BE_FAIL_ENDSYNC; stop = true; break; } else { // response is good. // FIXME (v2): copy what the server actually sent? if (!p->ascii_multiget) { // sigh... if part of a multiget we need to eat the END // markers down here. memcpy(r->buf+r->blen, ENDSTR, ENDLEN); r->blen += 5; } // advance buffer be->rbufused -= ENDLEN; if (be->rbufused > 0) { memmove(be->rbuf, be->rbuf+ENDLEN, be->rbufused); } } } else { flags = 0; stop = true; break; } be->state = mcp_backend_next; break; case mcp_backend_want_read: // Continuing a read from earlier r = p->client_resp; // take bread input and see if we're done reading the value, // else advance, set buffers, return next. P_DEBUG("%s: [want_read] r->bread: %d vlen: %lu\n", __func__, r->bread, r->resp.vlen); assert(be->rbufused != 0); size_t tocopy = be->rbufused < r->blen - r->bread ? be->rbufused : r->blen - r->bread; memcpy(r->buf+r->bread, be->rbuf, tocopy); r->bread += tocopy; if (r->bread >= r->blen) { // all done copying data. if (r->resp.type == MCMC_RESP_GET) { be->state = mcp_backend_read_end; } else { be->state = mcp_backend_next; } // shuffle remaining buffer. be->rbufused -= tocopy; if (be->rbufused > 0) { memmove(be->rbuf, be->rbuf+tocopy, be->rbufused); } } else { assert(tocopy == be->rbufused); // signal to caller to issue a read. be->rbufused = 0; flags = 0; stop = true; } break; case mcp_backend_next: _drive_machine_next(be, p); if (STAILQ_EMPTY(&be->io_head)) { stop = true; // if there're no pending requests, the read buffer // should also be empty. if (be->rbufused > 0) { flags = P_BE_FAIL_TRAILINGDATA; } break; } else { p = STAILQ_FIRST(&be->io_head); } // if leftover, keep processing IO's. // if no more data in buffer, need to re-set stack head and re-set // event. P_DEBUG("%s: [next] remain: %lu\n", __func__, be->rbufused); if (be->rbufused != 0) { // data trailing in the buffer, for a different request. be->state = mcp_backend_parse; } else { // need to read more data, buffer is empty. stop = true; } break; case mcp_backend_next_close: // we advance and return the current IO, then kill the conn. _drive_machine_next(be, p); stop = true; flags = P_BE_FAIL_INVALIDPROTOCOL; break; default: // TODO (v2): at some point (after v1?) this should attempt to recover, // though we should only get here from memory corruption and // bailing may be the right thing to do. fprintf(stderr, "%s: invalid backend state: %d\n", __func__, be->state); assert(false); } // switch } // while return flags; } static void _backend_reconnect(mcp_backend_t *be) { int status = mcmc_connect(be->client, be->name, be->port, be->connect_flags); if (status == MCMC_CONNECTED) { // TODO (v2): unexpected but lets let it be here. be->connecting = false; be->can_write = true; } else if (status == MCMC_CONNECTING) { be->connecting = true; be->can_write = false; } else { // failed to immediately re-establish the connection. // need to put the BE into a bad/retry state. be->connecting = false; be->can_write = true; } // re-create the write handler for the new file descriptor. // the main event will be re-assigned after this call. event_assign(&be->write_event, be->event_thread->base, mcmc_fd(be->client), EV_WRITE|EV_TIMEOUT, proxy_backend_handler, be); // do not need to re-assign the timer event because it's not tied to fd } // All we need to do here is schedule the backend to attempt to connect again. static void proxy_backend_retry_handler(const int fd, const short which, void *arg) { mcp_backend_t *be = arg; assert(which & EV_TIMEOUT); struct timeval tmp_time = be->tunables.connect; _backend_reconnect(be); _set_main_event(be, be->event_thread->base, EV_WRITE, &tmp_time, proxy_beconn_handler); } // must be called after _reset_bad_backend(), so the backend is currently // clear. // TODO (v2): extra counter for "backend connect tries" so it's still possible // to see dead backends exist static void _backend_failed(mcp_backend_t *be) { if (++be->failed_count > be->tunables.backend_failure_limit) { struct timeval tmp_time = be->tunables.retry; if (!be->bad) { P_DEBUG("%s: marking backend as bad\n", __func__); STAT_INCR(be->event_thread->ctx, backend_marked_bad, 1); LOGGER_LOG(NULL, LOG_PROXYEVENTS, LOGGER_PROXY_BE_ERROR, NULL, "markedbad", be->name, be->port, 0, NULL, 0); } be->bad = true; _set_main_event(be, be->event_thread->base, EV_TIMEOUT, &tmp_time, proxy_backend_retry_handler); } else { struct timeval tmp_time = be->tunables.connect; STAT_INCR(be->event_thread->ctx, backend_failed, 1); _backend_reconnect(be); _set_main_event(be, be->event_thread->base, EV_WRITE, &tmp_time, proxy_beconn_handler); } } // TODO (v2): add a second argument for assigning a specific error to all pending // IO's (ie; timeout). // The backend has gotten into a bad state (timed out, protocol desync, or // some other supposedly unrecoverable error: purge the queue and // cycle the socket. // Note that some types of errors may not require flushing the queue and // should be fixed as they're figured out. // _must_ be called from within the event thread. static int _reset_bad_backend(mcp_backend_t *be, enum proxy_be_failures err) { io_pending_proxy_t *io = NULL; P_DEBUG("%s: resetting bad backend: %s\n", __func__, proxy_be_failure_text[err]); // Can't use STAILQ_FOREACH() since return_io_pending() free's the current // io. STAILQ_FOREACH_SAFE maybe? int depth = be->depth; while (!STAILQ_EMPTY(&be->io_head)) { io = STAILQ_FIRST(&be->io_head); STAILQ_REMOVE_HEAD(&be->io_head, io_next); // TODO (v2): Unsure if this is the best way of surfacing errors to lua, // but will do for V1. io->client_resp->status = MCMC_ERR; be->depth--; return_io_pending((io_pending_t *)io); } STAILQ_INIT(&be->io_head); be->io_next = NULL; // also reset the write offset. // Only log if we don't already know it's messed up. if (!be->bad) { LOGGER_LOG(NULL, LOG_PROXYEVENTS, LOGGER_PROXY_BE_ERROR, NULL, proxy_be_failure_text[err], be->name, be->port, depth, be->rbuf, be->rbufused); } // reset buffer to blank state. be->rbufused = 0; be->pending_read = 0; // allow the _backend_failed() routine to connect when ready. _stop_write_event(be); _stop_main_event(be); _stop_timeout_event(be); mcmc_disconnect(be->client); // we leave the main event alone, because be_failed() always overwrites. return 0; } static int _prep_pending_write(mcp_backend_t *be) { struct iovec *iovs = be->write_iovs; io_pending_proxy_t *io = NULL; int iovused = 0; if (be->io_next == NULL) { // separate pointer for how far into the list we've flushed. io = STAILQ_FIRST(&be->io_head); } else { io = be->io_next; } assert(io != NULL); for (; io; io = STAILQ_NEXT(io, io_next)) { // TODO (v2): paranoia for now, but this check should never fire if (io->flushed) continue; if (io->iovcnt + iovused > BE_IOV_MAX) { // We will need to keep writing later. break; } memcpy(&iovs[iovused], io->iov, sizeof(struct iovec)*io->iovcnt); iovused += io->iovcnt; } return iovused; } // returns true if any pending writes were fully flushed. static void _post_pending_write(mcp_backend_t *be, ssize_t sent) { io_pending_proxy_t *io = be->io_next; if (io == NULL) { io = STAILQ_FIRST(&be->io_head); } for (; io; io = STAILQ_NEXT(io, io_next)) { bool flushed = true; if (io->flushed) continue; if (sent >= io->iovbytes) { // short circuit for common case. sent -= io->iovbytes; } else { io->iovbytes -= sent; for (int x = 0; x < io->iovcnt; x++) { struct iovec *iov = &io->iov[x]; if (sent >= iov->iov_len) { sent -= iov->iov_len; iov->iov_len = 0; } else { iov->iov_len -= sent; iov->iov_base = (char *)iov->iov_base + sent; sent = 0; flushed = false; break; } } } io->flushed = flushed; if (flushed) { be->pending_read++; } if (sent <= 0) { // really shouldn't be negative, though. assert(sent >= 0); break; } } // for // resume the flush from this point. if (io != NULL && !io->flushed) { be->io_next = io; } else { be->io_next = NULL; } } static int _flush_pending_write(mcp_backend_t *be) { int flags = 0; // Allow us to be called with an empty stack to prevent dev errors. if (STAILQ_EMPTY(&be->io_head)) { return 0; } int iovcnt = _prep_pending_write(be); ssize_t sent = writev(mcmc_fd(be->client), be->write_iovs, iovcnt); if (sent > 0) { _post_pending_write(be, sent); // still have unflushed pending IO's, check for write and re-loop. if (be->io_next) { be->can_write = false; flags |= EV_WRITE; } } else if (sent == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK) { be->can_write = false; flags |= EV_WRITE; } else { flags = -1; } } return flags; } // Libevent handler for backends in a connecting state. static void proxy_beconn_handler(const int fd, const short which, void *arg) { assert(arg != NULL); mcp_backend_t *be = arg; int flags = EV_TIMEOUT; struct timeval tmp_time = be->tunables.read; if (which & EV_TIMEOUT) { P_DEBUG("%s: backend timed out while connecting\n", __func__); if (be->connecting) { _reset_bad_backend(be, P_BE_FAIL_CONNTIMEOUT); } else { _reset_bad_backend(be, P_BE_FAIL_READVALIDATE); } _backend_failed(be); return; } if (which & EV_WRITE) { be->can_write = true; if (be->connecting) { if (_proxy_beconn_checkconnect(be) == -1) { return; } _set_main_event(be, be->event_thread->base, EV_READ, &tmp_time, proxy_beconn_handler); } // TODO: currently never taken, until validation is made optional. if (!be->validating) { int res = _flush_pending_write(be); if (res == -1) { _reset_bad_backend(be, P_BE_FAIL_WRITING); _backend_failed(be); return; } flags |= res; // FIXME: set write event? } } if (which & EV_READ) { assert(be->validating); int read = recv(mcmc_fd(be->client), be->rbuf + be->rbufused, READ_BUFFER_SIZE - be->rbufused, 0); if (read > 0) { mcmc_resp_t r; be->rbufused += read; int status = mcmc_parse_buf(be->client, be->rbuf, be->rbufused, &r); if (status == MCMC_ERR) { // Needed more data for a version line, somehow. I feel like // this should set off some alarms, but it is possible. if (r.code == MCMC_WANT_READ) { _set_main_event(be, be->event_thread->base, EV_READ, &tmp_time, proxy_beconn_handler); return; } _reset_bad_backend(be, P_BE_FAIL_READVALIDATE); _backend_failed(be); return; } if (r.code != MCMC_CODE_VERSION) { _reset_bad_backend(be, P_BE_FAIL_BADVALIDATE); _backend_failed(be); return; } be->validating = false; be->rbufused = 0; } else if (read == 0) { // not connected or error. _reset_bad_backend(be, P_BE_FAIL_DISCONNECTED); _backend_failed(be); return; } else if (read == -1) { // sit on epoll again. if (errno != EAGAIN && errno != EWOULDBLOCK) { _reset_bad_backend(be, P_BE_FAIL_READING); _backend_failed(be); return; } _set_main_event(be, be->event_thread->base, EV_READ, &tmp_time, proxy_beconn_handler); return; } // Passed validation, don't need to re-read, flush any pending writes. int res = _flush_pending_write(be); if (res == -1) { _reset_bad_backend(be, P_BE_FAIL_WRITING); _backend_failed(be); return; } if (flags & EV_WRITE) { _start_write_event(be); } if (be->pending_read) { _start_timeout_event(be); } } // switch to the primary persistent read event. if (!be->validating) { _set_main_event(be, be->event_thread->base, EV_READ|EV_PERSIST, NULL, proxy_backend_handler); } } // The libevent backend callback handler. // If we end up resetting a backend, it will get put back into a connecting // state. static void proxy_backend_handler(const int fd, const short which, void *arg) { mcp_backend_t *be = arg; if (which & EV_TIMEOUT) { P_DEBUG("%s: timeout received, killing backend queue\n", __func__); _reset_bad_backend(be, P_BE_FAIL_TIMEOUT); _backend_failed(be); return; } if (which & EV_WRITE) { be->can_write = true; int res = _flush_pending_write(be); if (res == -1) { _reset_bad_backend(be, P_BE_FAIL_WRITING); _backend_failed(be); return; } if (res & EV_WRITE) { _start_write_event(be); } } if (which & EV_READ) { // got a read event, always kill the pending read timer. _stop_timeout_event(be); // We do the syscall here before diving into the state machine to allow a // common code path for io_uring/epoll int read = recv(mcmc_fd(be->client), be->rbuf + be->rbufused, READ_BUFFER_SIZE - be->rbufused, 0); if (read > 0) { be->rbufused += read; int res = proxy_backend_drive_machine(be); if (res != 0) { _reset_bad_backend(be, res); _backend_failed(be); return; } } else if (read == 0) { // not connected or error. _reset_bad_backend(be, P_BE_FAIL_DISCONNECTED); _backend_failed(be); return; } else if (read == -1) { // sit on epoll again. if (errno != EAGAIN && errno != EWOULDBLOCK) { _reset_bad_backend(be, P_BE_FAIL_READING); _backend_failed(be); return; } } #ifdef PROXY_DEBUG if (!STAILQ_EMPTY(&be->io_head)) { P_DEBUG("backend has leftover IOs: %d\n", be->depth); } #endif } if (be->pending_read) { _start_timeout_event(be); } } void proxy_init_event_thread(proxy_event_thread_t *t, proxy_ctx_t *ctx, struct event_base *base) { t->ctx = ctx; #ifdef USE_EVENTFD t->event_fd = eventfd(0, EFD_NONBLOCK); if (t->event_fd == -1) { perror("failed to create backend notify eventfd"); exit(1); } t->be_event_fd = eventfd(0, EFD_NONBLOCK); if (t->be_event_fd == -1) { perror("failed to create backend notify eventfd"); exit(1); } #else int fds[2]; if (pipe(fds)) { perror("can't create proxy backend notify pipe"); exit(1); } t->notify_receive_fd = fds[0]; t->notify_send_fd = fds[1]; if (pipe(fds)) { perror("can't create proxy backend connection notify pipe"); exit(1); } t->be_notify_receive_fd = fds[0]; t->be_notify_send_fd = fds[1]; #endif // incoming request queue. STAILQ_INIT(&t->io_head_in); STAILQ_INIT(&t->beconn_head_in); pthread_mutex_init(&t->mutex, NULL); pthread_cond_init(&t->cond, NULL); // initialize the event system. #ifdef HAVE_LIBURING if (t->ctx->use_uring) { fprintf(stderr, "Sorry, io_uring not supported right now\n"); abort(); } #endif if (base == NULL) { struct event_config *ev_config; ev_config = event_config_new(); event_config_set_flag(ev_config, EVENT_BASE_FLAG_NOLOCK); t->base = event_base_new_with_config(ev_config); event_config_free(ev_config); if (! t->base) { fprintf(stderr, "Can't allocate event base\n"); exit(1); } } else { // reusing an event base from a worker thread. t->base = base; } // listen for notifications. // NULL was thread_libevent_process // FIXME (v2): use modern format? (event_assign) #ifdef USE_EVENTFD event_set(&t->notify_event, t->event_fd, EV_READ | EV_PERSIST, proxy_event_handler, t); event_set(&t->beconn_event, t->be_event_fd, EV_READ | EV_PERSIST, proxy_event_beconn, t); #else event_set(&t->notify_event, t->notify_receive_fd, EV_READ | EV_PERSIST, proxy_event_handler, t); event_set(&t->beconn_event, t->be_notify_receive_fd, EV_READ | EV_PERSIST, proxy_event_beconn, t); #endif event_base_set(t->base, &t->notify_event); if (event_add(&t->notify_event, 0) == -1) { fprintf(stderr, "Can't monitor libevent notify pipe\n"); exit(1); } event_base_set(t->base, &t->beconn_event); if (event_add(&t->beconn_event, 0) == -1) { fprintf(stderr, "Can't monitor libevent notify pipe\n"); exit(1); } } memcached-1.6.20/crc32c.h0000664000175000017500000000140214301776131011661 00000000000000#ifndef CRC32C_H #define CRC32C_H // crc32c.h -- header for crc32c.c // Copyright (C) 2015 Mark Adler // See crc32c.c for the license. #include // Return the CRC-32C of buf[0..len-1] given the starting CRC crc. This can be // used to calculate the CRC of a sequence of bytes a chunk at a time, using // the previously returned crc in the next call. The first call must be with // crc == 0. crc32c() uses the Intel crc32 hardware instruction if available. typedef uint32_t (*crc_func)(uint32_t crc, const void *buf, size_t len); extern crc_func crc32c; void crc32c_init(void); // Expose a prototype for the crc32c software variant simply for testing purposes uint32_t crc32c_sw(uint32_t crc, void const *buf, size_t len); #endif /* CRC32C_H */ memcached-1.6.20/m4/0000775000175000017500000000000014427544305011041 500000000000000memcached-1.6.20/m4/c99-backport.m40000664000175000017500000001210413704126374013427 00000000000000# AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) # ---------------------------------------------------------------- # If the C compiler is not in ISO C99 mode by default, try to add an # option to output variable CC to make it so. This macro tries # various options that select ISO C99 on some system or another. It # considers the compiler to be in ISO C99 mode if it handles _Bool, # // comments, flexible array members, inline, long long int, mixed # code and declarations, named initialization of structs, restrict, # va_copy, varargs macros, variable declarations in for loops and # variable length arrays. AC_DEFUN([AC_PROG_CC_C99], [AC_C_STD_TRY([c99], [[#include #include #include #include #include // Check varargs macros. These examples are taken from C99 6.10.3.5. #define debug(...) fprintf (stderr, __VA_ARGS__) #define showlist(...) puts (#__VA_ARGS__) #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) static void test_varargs_macros (void) { int x = 1234; int y = 5678; debug ("Flag"); debug ("X = %d\n", x); showlist (The first, second, and third items.); report (x>y, "x is %d but y is %d", x, y); } // Check long long types. #define BIG64 18446744073709551615ull #define BIG32 4294967295ul #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) #if !BIG_OK your preprocessor is broken; #endif #if BIG_OK #else your preprocessor is broken; #endif static long long int bignum = -9223372036854775807LL; static unsigned long long int ubignum = BIG64; struct incomplete_array { int datasize; double data[]; }; struct named_init { int number; const wchar_t *name; double average; }; typedef const char *ccp; static inline int test_restrict (ccp restrict text) { // See if C++-style comments work. // Iterate through items via the restricted pointer. // Also check for declarations in for loops. for (unsigned int i = 0; *(text+i) != '\0'; ++i) continue; return 0; } // Check varargs and va_copy. static void test_varargs (const char *format, ...) { va_list args; va_start (args, format); va_list args_copy; va_copy (args_copy, args); const char *str; int number; float fnumber; while (*format) { switch (*format++) { case 's': // string str = va_arg (args_copy, const char *); break; case 'd': // int number = va_arg (args_copy, int); break; case 'f': // float fnumber = va_arg (args_copy, double); break; default: break; } } va_end (args_copy); va_end (args); } ]], [[ // Check bool. _Bool success = false; // Check restrict. if (test_restrict ("String literal") == 0) success = true; char *restrict newvar = "Another string"; // Check varargs. test_varargs ("s, d' f .", "string", 65, 34.234); test_varargs_macros (); // Check flexible array members. struct incomplete_array *ia = malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); ia->datasize = 10; for (int i = 0; i < ia->datasize; ++i) ia->data[i] = i * 1.234; // Check named initializers. struct named_init ni = { .number = 34, .name = L"Test wide string", .average = 543.34343, }; ni.number = 58; int dynamic_array[ni.number]; dynamic_array[ni.number - 1] = 543; // work around unused variable warnings return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x' || dynamic_array[ni.number - 1] != 543); ]], dnl Try dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999) dnl AIX -qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99) dnl Intel ICC -c99 dnl IRIX -c99 dnl Solaris (unused because it causes the compiler to assume C99 semantics for dnl library functions, and this is invalid before Solaris 10: -xc99) dnl Tru64 -c99 dnl with extended modes being tried first. [[-std=gnu99 -c99 -qlanglvl=extc99]], [$1], [$2])[]dnl ])# AC_PROG_CC_C99 # AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST, # ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE) # -------------------------------------------------------------- # Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99') # by trying to compile a program of TEST-PROLOGUE and TEST-BODY. If this fails, # try again with each compiler option in the space-separated OPTION-LIST; if one # helps, append it to CC. If eventually successful, run ACTION-IF-AVAILABLE, # else ACTION-IF-UNAVAILABLE. AC_DEFUN([AC_C_STD_TRY], [AC_MSG_CHECKING([for $CC option to accept ISO ]m4_translit($1, [c], [C])) AC_CACHE_VAL(ac_cv_prog_cc_$1, [ac_cv_prog_cc_$1=no ac_save_CC=$CC AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])]) for ac_arg in '' $4 do CC="$ac_save_CC $ac_arg" _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg]) test "x$ac_cv_prog_cc_$1" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC ])# AC_CACHE_VAL case "x$ac_cv_prog_cc_$1" in x) AC_MSG_RESULT([none needed]) ;; xno) AC_MSG_RESULT([unsupported]) ;; *) CC="$CC $ac_cv_prog_cc_$1" AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;; esac AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6]) ])# AC_C_STD_TRY memcached-1.6.20/version.m40000664000175000017500000000004614427544303012366 00000000000000m4_define([VERSION_NUMBER], [1.6.20]) memcached-1.6.20/LICENSE.bipbuffer0000664000175000017500000000270013704126374013407 00000000000000Copyright (c) 2011, Willem-Hendrik Thiart All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The names of its contributors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WILLEM-HENDRIK THIART BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. memcached-1.6.20/proxy_ustats.c0000664000175000017500000000515014427543277013401 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "proxy.h" // mcp.add_stat(index, name) // creates a custom lua stats counter int mcplib_add_stat(lua_State *L) { int idx = luaL_checkinteger(L, -2); const char *name = luaL_checkstring(L, -1); if (idx < 1) { proxy_lua_error(L, "stat index must be 1 or higher"); return 0; } // max user counters? 1024? some weird number. if (idx > 1024) { proxy_lua_error(L, "stat index must be 1024 or less"); return 0; } // max name length? avoids errors if something huge gets thrown in. if (strlen(name) > STAT_KEY_LEN - 6) { // we prepend "user_" to the output. + null byte. proxy_lua_ferror(L, "stat name too long: %s\n", name); return 0; } // restrict characters, at least no spaces/newlines. for (int x = 0; x < strlen(name); x++) { if (isspace(name[x])) { proxy_lua_error(L, "stat cannot contain spaces or newlines"); return 0; } } proxy_ctx_t *ctx = PROXY_GET_CTX(L); STAT_L(ctx); struct proxy_user_stats *us = &ctx->user_stats; // if num_stats is 0 we need to init sizes. // TODO (v2): malloc fail checking. (should be rare/impossible) if (us->num_stats < idx) { // don't allocate counters memory for the global ctx. char **nnames = calloc(idx, sizeof(char *)); if (us->names != NULL) { for (int x = 0; x < us->num_stats; x++) { nnames[x] = us->names[x]; } free(us->names); } us->names = nnames; us->num_stats = idx; } idx--; // real slot start as 0. // if slot has string in it, free first if (us->names[idx] != NULL) { free(us->names[idx]); } // strdup name into string slot // TODO (v2): malloc failure. us->names[idx] = strdup(name); STAT_UL(ctx); return 0; } int mcplib_stat(lua_State *L) { LIBEVENT_THREAD *t = PROXY_GET_THR(L); if (t == NULL) { proxy_lua_error(L, "stat must be called from router handlers"); return 0; } struct proxy_user_stats *tus = t->proxy_user_stats; if (tus == NULL) { proxy_lua_error(L, "no stats counters initialized"); return 0; } int idx = luaL_checkinteger(L, -2); int change = luaL_checkinteger(L, -1); if (idx < 1 || idx > tus->num_stats) { proxy_lua_error(L, "stat index out of range"); return 0; } idx--; // actual array is 0 indexed. WSTAT_L(t); tus->counters[idx] += change; WSTAT_UL(t); return 0; } memcached-1.6.20/items.c0000664000175000017500000017643414403667314011745 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "memcached.h" #include "bipbuffer.h" #include "slab_automove.h" #include "storage.h" #ifdef EXTSTORE #include "slab_automove_extstore.h" #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* Forward Declarations */ static void item_link_q(item *it); static void item_unlink_q(item *it); static unsigned int lru_type_map[4] = {HOT_LRU, WARM_LRU, COLD_LRU, TEMP_LRU}; #define LARGEST_ID POWER_LARGEST typedef struct { uint64_t evicted; uint64_t evicted_nonzero; uint64_t reclaimed; uint64_t outofmemory; uint64_t tailrepairs; uint64_t expired_unfetched; /* items reclaimed but never touched */ uint64_t evicted_unfetched; /* items evicted but never touched */ uint64_t evicted_active; /* items evicted that should have been shuffled */ uint64_t crawler_reclaimed; uint64_t crawler_items_checked; uint64_t lrutail_reflocked; uint64_t moves_to_cold; uint64_t moves_to_warm; uint64_t moves_within_lru; uint64_t direct_reclaims; uint64_t hits_to_hot; uint64_t hits_to_warm; uint64_t hits_to_cold; uint64_t hits_to_temp; uint64_t mem_requested; rel_time_t evicted_time; } itemstats_t; static item *heads[LARGEST_ID]; static item *tails[LARGEST_ID]; static itemstats_t itemstats[LARGEST_ID]; static unsigned int sizes[LARGEST_ID]; static uint64_t sizes_bytes[LARGEST_ID]; static unsigned int *stats_sizes_hist = NULL; static uint64_t stats_sizes_cas_min = 0; static int stats_sizes_buckets = 0; static uint64_t cas_id = 0; static volatile int do_run_lru_maintainer_thread = 0; static pthread_mutex_t lru_maintainer_lock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t cas_id_lock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t stats_sizes_lock = PTHREAD_MUTEX_INITIALIZER; void item_stats_reset(void) { int i; for (i = 0; i < LARGEST_ID; i++) { pthread_mutex_lock(&lru_locks[i]); memset(&itemstats[i], 0, sizeof(itemstats_t)); pthread_mutex_unlock(&lru_locks[i]); } } /* called with class lru lock held */ void do_item_stats_add_crawl(const int i, const uint64_t reclaimed, const uint64_t unfetched, const uint64_t checked) { itemstats[i].crawler_reclaimed += reclaimed; itemstats[i].expired_unfetched += unfetched; itemstats[i].crawler_items_checked += checked; } typedef struct _lru_bump_buf { struct _lru_bump_buf *prev; struct _lru_bump_buf *next; pthread_mutex_t mutex; bipbuf_t *buf; uint64_t dropped; } lru_bump_buf; typedef struct { item *it; uint32_t hv; } lru_bump_entry; static lru_bump_buf *bump_buf_head = NULL; static lru_bump_buf *bump_buf_tail = NULL; static pthread_mutex_t bump_buf_lock = PTHREAD_MUTEX_INITIALIZER; /* TODO: tunable? Need bench results */ #define LRU_BUMP_BUF_SIZE 8192 static bool lru_bump_async(lru_bump_buf *b, item *it, uint32_t hv); static uint64_t lru_total_bumps_dropped(void); /* Get the next CAS id for a new item. */ /* TODO: refactor some atomics for this. */ uint64_t get_cas_id(void) { pthread_mutex_lock(&cas_id_lock); uint64_t next_id = ++cas_id; pthread_mutex_unlock(&cas_id_lock); return next_id; } void set_cas_id(uint64_t new_cas) { pthread_mutex_lock(&cas_id_lock); cas_id = new_cas; pthread_mutex_unlock(&cas_id_lock); } int item_is_flushed(item *it) { rel_time_t oldest_live = settings.oldest_live; uint64_t cas = ITEM_get_cas(it); uint64_t oldest_cas = settings.oldest_cas; if (oldest_live == 0 || oldest_live > current_time) return 0; if ((it->time <= oldest_live) || (oldest_cas != 0 && cas != 0 && cas < oldest_cas)) { return 1; } return 0; } /* must be locked before call */ unsigned int do_get_lru_size(uint32_t id) { return sizes[id]; } /* Enable this for reference-count debugging. */ #if 0 # define DEBUG_REFCNT(it,op) \ fprintf(stderr, "item %x refcnt(%c) %d %c%c%c\n", \ it, op, it->refcount, \ (it->it_flags & ITEM_LINKED) ? 'L' : ' ', \ (it->it_flags & ITEM_SLABBED) ? 'S' : ' ') #else # define DEBUG_REFCNT(it,op) while(0) #endif /** * Generates the variable-sized part of the header for an object. * * nkey - The length of the key * flags - key flags * nbytes - Number of bytes to hold value and addition CRLF terminator * suffix - Buffer for the "VALUE" line suffix (flags, size). * nsuffix - The length of the suffix is stored here. * * Returns the total size of the header. */ static size_t item_make_header(const uint8_t nkey, const unsigned int flags, const int nbytes, char *suffix, uint8_t *nsuffix) { if (flags == 0) { *nsuffix = 0; } else { *nsuffix = sizeof(flags); } return sizeof(item) + nkey + *nsuffix + nbytes; } item *do_item_alloc_pull(const size_t ntotal, const unsigned int id) { item *it = NULL; int i; /* If no memory is available, attempt a direct LRU juggle/eviction */ /* This is a race in order to simplify lru_pull_tail; in cases where * locked items are on the tail, you want them to fall out and cause * occasional OOM's, rather than internally work around them. * This also gives one fewer code path for slab alloc/free */ for (i = 0; i < 10; i++) { /* Try to reclaim memory first */ if (!settings.lru_segmented) { lru_pull_tail(id, COLD_LRU, 0, 0, 0, NULL); } it = slabs_alloc(ntotal, id, 0); if (it == NULL) { // We send '0' in for "total_bytes" as this routine is always // pulling to evict, or forcing HOT -> COLD migration. // As of this writing, total_bytes isn't at all used with COLD_LRU. if (lru_pull_tail(id, COLD_LRU, 0, LRU_PULL_EVICT, 0, NULL) <= 0) { if (settings.lru_segmented) { lru_pull_tail(id, HOT_LRU, 0, 0, 0, NULL); } else { break; } } } else { break; } } if (i > 0) { pthread_mutex_lock(&lru_locks[id]); itemstats[id].direct_reclaims += i; pthread_mutex_unlock(&lru_locks[id]); } return it; } /* Chain another chunk onto this chunk. */ /* slab mover: if it finds a chunk without ITEM_CHUNK flag, and no ITEM_LINKED * flag, it counts as busy and skips. * I think it might still not be safe to do linking outside of the slab lock */ item_chunk *do_item_alloc_chunk(item_chunk *ch, const size_t bytes_remain) { // TODO: Should be a cleaner way of finding real size with slabber calls size_t size = bytes_remain + sizeof(item_chunk); if (size > settings.slab_chunk_size_max) size = settings.slab_chunk_size_max; unsigned int id = slabs_clsid(size); item_chunk *nch = (item_chunk *) do_item_alloc_pull(size, id); if (nch == NULL) { // The final chunk in a large item will attempt to be a more // appropriately sized chunk to minimize memory overhead. However, if // there's no memory available in the lower slab classes we fail the // SET. In these cases as a fallback we ensure we attempt to evict a // max-size item and reuse a large chunk. if (size == settings.slab_chunk_size_max) { return NULL; } else { size = settings.slab_chunk_size_max; id = slabs_clsid(size); nch = (item_chunk *) do_item_alloc_pull(size, id); if (nch == NULL) return NULL; } } // link in. // ITEM_CHUNK[ED] bits need to be protected by the slabs lock. slabs_mlock(); nch->head = ch->head; ch->next = nch; nch->prev = ch; nch->next = 0; nch->used = 0; nch->slabs_clsid = id; nch->size = size - sizeof(item_chunk); nch->it_flags |= ITEM_CHUNK; slabs_munlock(); return nch; } item *do_item_alloc(const char *key, const size_t nkey, const unsigned int flags, const rel_time_t exptime, const int nbytes) { uint8_t nsuffix; item *it = NULL; char suffix[40]; // Avoid potential underflows. if (nbytes < 2) return 0; size_t ntotal = item_make_header(nkey + 1, flags, nbytes, suffix, &nsuffix); if (settings.use_cas) { ntotal += sizeof(uint64_t); } unsigned int id = slabs_clsid(ntotal); unsigned int hdr_id = 0; if (id == 0) return 0; /* This is a large item. Allocate a header object now, lazily allocate * chunks while reading the upload. */ if (ntotal > settings.slab_chunk_size_max) { /* We still link this item into the LRU for the larger slab class, but * we're pulling a header from an entirely different slab class. The * free routines handle large items specifically. */ int htotal = nkey + 1 + nsuffix + sizeof(item) + sizeof(item_chunk); if (settings.use_cas) { htotal += sizeof(uint64_t); } #ifdef NEED_ALIGN // header chunk needs to be padded on some systems int remain = htotal % 8; if (remain != 0) { htotal += 8 - remain; } #endif hdr_id = slabs_clsid(htotal); it = do_item_alloc_pull(htotal, hdr_id); /* setting ITEM_CHUNKED is fine here because we aren't LINKED yet. */ if (it != NULL) it->it_flags |= ITEM_CHUNKED; } else { it = do_item_alloc_pull(ntotal, id); } if (it == NULL) { pthread_mutex_lock(&lru_locks[id]); itemstats[id].outofmemory++; pthread_mutex_unlock(&lru_locks[id]); return NULL; } assert(it->it_flags == 0 || it->it_flags == ITEM_CHUNKED); //assert(it != heads[id]); /* Refcount is seeded to 1 by slabs_alloc() */ it->next = it->prev = 0; /* Items are initially loaded into the HOT_LRU. This is '0' but I want at * least a note here. Compiler (hopefully?) optimizes this out. */ if (settings.temp_lru && exptime - current_time <= settings.temporary_ttl) { id |= TEMP_LRU; } else if (settings.lru_segmented) { id |= HOT_LRU; } else { /* There is only COLD in compat-mode */ id |= COLD_LRU; } it->slabs_clsid = id; DEBUG_REFCNT(it, '*'); it->it_flags |= settings.use_cas ? ITEM_CAS : 0; it->it_flags |= nsuffix != 0 ? ITEM_CFLAGS : 0; it->nkey = nkey; it->nbytes = nbytes; memcpy(ITEM_key(it), key, nkey); it->exptime = exptime; if (nsuffix > 0) { memcpy(ITEM_suffix(it), &flags, sizeof(flags)); } /* Initialize internal chunk. */ if (it->it_flags & ITEM_CHUNKED) { item_chunk *chunk = (item_chunk *) ITEM_schunk(it); chunk->next = 0; chunk->prev = 0; chunk->used = 0; chunk->size = 0; chunk->head = it; chunk->orig_clsid = hdr_id; } it->h_next = 0; return it; } void item_free(item *it) { size_t ntotal = ITEM_ntotal(it); unsigned int clsid; assert((it->it_flags & ITEM_LINKED) == 0); assert(it != heads[it->slabs_clsid]); assert(it != tails[it->slabs_clsid]); assert(it->refcount == 0); /* so slab size changer can tell later if item is already free or not */ clsid = ITEM_clsid(it); DEBUG_REFCNT(it, 'F'); slabs_free(it, ntotal, clsid); } /** * Returns true if an item will fit in the cache (its size does not exceed * the maximum for a cache entry.) */ bool item_size_ok(const size_t nkey, const int flags, const int nbytes) { char prefix[40]; uint8_t nsuffix; if (nbytes < 2) return false; size_t ntotal = item_make_header(nkey + 1, flags, nbytes, prefix, &nsuffix); if (settings.use_cas) { ntotal += sizeof(uint64_t); } return slabs_clsid(ntotal) != 0; } /* fixing stats/references during warm start */ void do_item_link_fixup(item *it) { item **head, **tail; int ntotal = ITEM_ntotal(it); uint32_t hv = hash(ITEM_key(it), it->nkey); assoc_insert(it, hv); head = &heads[it->slabs_clsid]; tail = &tails[it->slabs_clsid]; if (it->prev == 0 && *head == 0) *head = it; if (it->next == 0 && *tail == 0) *tail = it; sizes[it->slabs_clsid]++; sizes_bytes[it->slabs_clsid] += ntotal; STATS_LOCK(); stats_state.curr_bytes += ntotal; stats_state.curr_items += 1; stats.total_items += 1; STATS_UNLOCK(); item_stats_sizes_add(it); return; } static void do_item_link_q(item *it) { /* item is the new head */ item **head, **tail; assert((it->it_flags & ITEM_SLABBED) == 0); head = &heads[it->slabs_clsid]; tail = &tails[it->slabs_clsid]; assert(it != *head); assert((*head && *tail) || (*head == 0 && *tail == 0)); it->prev = 0; it->next = *head; if (it->next) it->next->prev = it; *head = it; if (*tail == 0) *tail = it; sizes[it->slabs_clsid]++; #ifdef EXTSTORE if (it->it_flags & ITEM_HDR) { sizes_bytes[it->slabs_clsid] += (ITEM_ntotal(it) - it->nbytes) + sizeof(item_hdr); } else { sizes_bytes[it->slabs_clsid] += ITEM_ntotal(it); } #else sizes_bytes[it->slabs_clsid] += ITEM_ntotal(it); #endif return; } static void item_link_q(item *it) { pthread_mutex_lock(&lru_locks[it->slabs_clsid]); do_item_link_q(it); pthread_mutex_unlock(&lru_locks[it->slabs_clsid]); } static void item_link_q_warm(item *it) { pthread_mutex_lock(&lru_locks[it->slabs_clsid]); do_item_link_q(it); itemstats[it->slabs_clsid].moves_to_warm++; pthread_mutex_unlock(&lru_locks[it->slabs_clsid]); } static void do_item_unlink_q(item *it) { item **head, **tail; head = &heads[it->slabs_clsid]; tail = &tails[it->slabs_clsid]; if (*head == it) { assert(it->prev == 0); *head = it->next; } if (*tail == it) { assert(it->next == 0); *tail = it->prev; } assert(it->next != it); assert(it->prev != it); if (it->next) it->next->prev = it->prev; if (it->prev) it->prev->next = it->next; sizes[it->slabs_clsid]--; #ifdef EXTSTORE if (it->it_flags & ITEM_HDR) { sizes_bytes[it->slabs_clsid] -= (ITEM_ntotal(it) - it->nbytes) + sizeof(item_hdr); } else { sizes_bytes[it->slabs_clsid] -= ITEM_ntotal(it); } #else sizes_bytes[it->slabs_clsid] -= ITEM_ntotal(it); #endif return; } static void item_unlink_q(item *it) { pthread_mutex_lock(&lru_locks[it->slabs_clsid]); do_item_unlink_q(it); pthread_mutex_unlock(&lru_locks[it->slabs_clsid]); } int do_item_link(item *it, const uint32_t hv) { MEMCACHED_ITEM_LINK(ITEM_key(it), it->nkey, it->nbytes); assert((it->it_flags & (ITEM_LINKED|ITEM_SLABBED)) == 0); it->it_flags |= ITEM_LINKED; it->time = current_time; STATS_LOCK(); stats_state.curr_bytes += ITEM_ntotal(it); stats_state.curr_items += 1; stats.total_items += 1; STATS_UNLOCK(); /* Allocate a new CAS ID on link. */ ITEM_set_cas(it, (settings.use_cas) ? get_cas_id() : 0); assoc_insert(it, hv); item_link_q(it); refcount_incr(it); item_stats_sizes_add(it); return 1; } void do_item_unlink(item *it, const uint32_t hv) { MEMCACHED_ITEM_UNLINK(ITEM_key(it), it->nkey, it->nbytes); if ((it->it_flags & ITEM_LINKED) != 0) { it->it_flags &= ~ITEM_LINKED; STATS_LOCK(); stats_state.curr_bytes -= ITEM_ntotal(it); stats_state.curr_items -= 1; STATS_UNLOCK(); item_stats_sizes_remove(it); assoc_delete(ITEM_key(it), it->nkey, hv); item_unlink_q(it); do_item_remove(it); } } /* FIXME: Is it necessary to keep this copy/pasted code? */ void do_item_unlink_nolock(item *it, const uint32_t hv) { MEMCACHED_ITEM_UNLINK(ITEM_key(it), it->nkey, it->nbytes); if ((it->it_flags & ITEM_LINKED) != 0) { it->it_flags &= ~ITEM_LINKED; STATS_LOCK(); stats_state.curr_bytes -= ITEM_ntotal(it); stats_state.curr_items -= 1; STATS_UNLOCK(); item_stats_sizes_remove(it); assoc_delete(ITEM_key(it), it->nkey, hv); do_item_unlink_q(it); do_item_remove(it); } } void do_item_remove(item *it) { MEMCACHED_ITEM_REMOVE(ITEM_key(it), it->nkey, it->nbytes); assert((it->it_flags & ITEM_SLABBED) == 0); assert(it->refcount > 0); if (refcount_decr(it) == 0) { item_free(it); } } /* Bump the last accessed time, or relink if we're in compat mode */ void do_item_update(item *it) { MEMCACHED_ITEM_UPDATE(ITEM_key(it), it->nkey, it->nbytes); /* Hits to COLD_LRU immediately move to WARM. */ if (settings.lru_segmented) { assert((it->it_flags & ITEM_SLABBED) == 0); if ((it->it_flags & ITEM_LINKED) != 0) { if (ITEM_lruid(it) == COLD_LRU && (it->it_flags & ITEM_ACTIVE)) { it->time = current_time; item_unlink_q(it); it->slabs_clsid = ITEM_clsid(it); it->slabs_clsid |= WARM_LRU; it->it_flags &= ~ITEM_ACTIVE; item_link_q_warm(it); } else { it->time = current_time; } } } else if (it->time < current_time - ITEM_UPDATE_INTERVAL) { assert((it->it_flags & ITEM_SLABBED) == 0); if ((it->it_flags & ITEM_LINKED) != 0) { it->time = current_time; item_unlink_q(it); item_link_q(it); } } } int do_item_replace(item *it, item *new_it, const uint32_t hv) { MEMCACHED_ITEM_REPLACE(ITEM_key(it), it->nkey, it->nbytes, ITEM_key(new_it), new_it->nkey, new_it->nbytes); assert((it->it_flags & ITEM_SLABBED) == 0); do_item_unlink(it, hv); return do_item_link(new_it, hv); } /*@null@*/ /* This is walking the line of violating lock order, but I think it's safe. * If the LRU lock is held, an item in the LRU cannot be wiped and freed. * The data could possibly be overwritten, but this is only accessing the * headers. * It may not be the best idea to leave it like this, but for now it's safe. */ char *item_cachedump(const unsigned int slabs_clsid, const unsigned int limit, unsigned int *bytes) { unsigned int memlimit = 2 * 1024 * 1024; /* 2MB max response size */ char *buffer; unsigned int bufcurr; item *it; unsigned int len; unsigned int shown = 0; char key_temp[KEY_MAX_LENGTH + 1]; char temp[512]; unsigned int id = slabs_clsid; id |= COLD_LRU; pthread_mutex_lock(&lru_locks[id]); it = heads[id]; buffer = malloc((size_t)memlimit); if (buffer == 0) { pthread_mutex_unlock(&lru_locks[id]); return NULL; } bufcurr = 0; while (it != NULL && (limit == 0 || shown < limit)) { assert(it->nkey <= KEY_MAX_LENGTH); // protect from printing binary keys. if ((it->nbytes == 0 && it->nkey == 0) || (it->it_flags & ITEM_KEY_BINARY)) { it = it->next; continue; } /* Copy the key since it may not be null-terminated in the struct */ strncpy(key_temp, ITEM_key(it), it->nkey); key_temp[it->nkey] = 0x00; /* terminate */ len = snprintf(temp, sizeof(temp), "ITEM %s [%d b; %llu s]\r\n", key_temp, it->nbytes - 2, it->exptime == 0 ? 0 : (unsigned long long)it->exptime + process_started); if (bufcurr + len + 6 > memlimit) /* 6 is END\r\n\0 */ break; memcpy(buffer + bufcurr, temp, len); bufcurr += len; shown++; it = it->next; } memcpy(buffer + bufcurr, "END\r\n", 6); bufcurr += 5; *bytes = bufcurr; pthread_mutex_unlock(&lru_locks[id]); return buffer; } /* With refactoring of the various stats code the automover won't need a * custom function here. */ void fill_item_stats_automove(item_stats_automove *am) { int n; for (n = 0; n < MAX_NUMBER_OF_SLAB_CLASSES; n++) { item_stats_automove *cur = &am[n]; // outofmemory records into HOT int i = n | HOT_LRU; pthread_mutex_lock(&lru_locks[i]); cur->outofmemory = itemstats[i].outofmemory; pthread_mutex_unlock(&lru_locks[i]); // evictions and tail age are from COLD i = n | COLD_LRU; pthread_mutex_lock(&lru_locks[i]); cur->evicted = itemstats[i].evicted; if (!tails[i]) { cur->age = 0; } else if (tails[i]->nbytes == 0 && tails[i]->nkey == 0 && tails[i]->it_flags == 1) { /* it's a crawler, check previous entry */ if (tails[i]->prev) { cur->age = current_time - tails[i]->prev->time; } else { cur->age = 0; } } else { cur->age = current_time - tails[i]->time; } pthread_mutex_unlock(&lru_locks[i]); } } void item_stats_totals(ADD_STAT add_stats, void *c) { itemstats_t totals; memset(&totals, 0, sizeof(itemstats_t)); int n; for (n = 0; n < MAX_NUMBER_OF_SLAB_CLASSES; n++) { int x; int i; for (x = 0; x < 4; x++) { i = n | lru_type_map[x]; pthread_mutex_lock(&lru_locks[i]); totals.expired_unfetched += itemstats[i].expired_unfetched; totals.evicted_unfetched += itemstats[i].evicted_unfetched; totals.evicted_active += itemstats[i].evicted_active; totals.evicted += itemstats[i].evicted; totals.reclaimed += itemstats[i].reclaimed; totals.crawler_reclaimed += itemstats[i].crawler_reclaimed; totals.crawler_items_checked += itemstats[i].crawler_items_checked; totals.lrutail_reflocked += itemstats[i].lrutail_reflocked; totals.moves_to_cold += itemstats[i].moves_to_cold; totals.moves_to_warm += itemstats[i].moves_to_warm; totals.moves_within_lru += itemstats[i].moves_within_lru; totals.direct_reclaims += itemstats[i].direct_reclaims; pthread_mutex_unlock(&lru_locks[i]); } } APPEND_STAT("expired_unfetched", "%llu", (unsigned long long)totals.expired_unfetched); APPEND_STAT("evicted_unfetched", "%llu", (unsigned long long)totals.evicted_unfetched); if (settings.lru_maintainer_thread) { APPEND_STAT("evicted_active", "%llu", (unsigned long long)totals.evicted_active); } APPEND_STAT("evictions", "%llu", (unsigned long long)totals.evicted); APPEND_STAT("reclaimed", "%llu", (unsigned long long)totals.reclaimed); APPEND_STAT("crawler_reclaimed", "%llu", (unsigned long long)totals.crawler_reclaimed); APPEND_STAT("crawler_items_checked", "%llu", (unsigned long long)totals.crawler_items_checked); APPEND_STAT("lrutail_reflocked", "%llu", (unsigned long long)totals.lrutail_reflocked); if (settings.lru_maintainer_thread) { APPEND_STAT("moves_to_cold", "%llu", (unsigned long long)totals.moves_to_cold); APPEND_STAT("moves_to_warm", "%llu", (unsigned long long)totals.moves_to_warm); APPEND_STAT("moves_within_lru", "%llu", (unsigned long long)totals.moves_within_lru); APPEND_STAT("direct_reclaims", "%llu", (unsigned long long)totals.direct_reclaims); APPEND_STAT("lru_bumps_dropped", "%llu", (unsigned long long)lru_total_bumps_dropped()); } } void item_stats(ADD_STAT add_stats, void *c) { struct thread_stats thread_stats; threadlocal_stats_aggregate(&thread_stats); itemstats_t totals; int n; for (n = 0; n < MAX_NUMBER_OF_SLAB_CLASSES; n++) { memset(&totals, 0, sizeof(itemstats_t)); int x; int i; unsigned int size = 0; unsigned int age = 0; unsigned int age_hot = 0; unsigned int age_warm = 0; unsigned int lru_size_map[4]; const char *fmt = "items:%d:%s"; char key_str[STAT_KEY_LEN]; char val_str[STAT_VAL_LEN]; int klen = 0, vlen = 0; for (x = 0; x < 4; x++) { i = n | lru_type_map[x]; pthread_mutex_lock(&lru_locks[i]); totals.evicted += itemstats[i].evicted; totals.evicted_nonzero += itemstats[i].evicted_nonzero; totals.outofmemory += itemstats[i].outofmemory; totals.tailrepairs += itemstats[i].tailrepairs; totals.reclaimed += itemstats[i].reclaimed; totals.expired_unfetched += itemstats[i].expired_unfetched; totals.evicted_unfetched += itemstats[i].evicted_unfetched; totals.evicted_active += itemstats[i].evicted_active; totals.crawler_reclaimed += itemstats[i].crawler_reclaimed; totals.crawler_items_checked += itemstats[i].crawler_items_checked; totals.lrutail_reflocked += itemstats[i].lrutail_reflocked; totals.moves_to_cold += itemstats[i].moves_to_cold; totals.moves_to_warm += itemstats[i].moves_to_warm; totals.moves_within_lru += itemstats[i].moves_within_lru; totals.direct_reclaims += itemstats[i].direct_reclaims; totals.mem_requested += sizes_bytes[i]; size += sizes[i]; lru_size_map[x] = sizes[i]; if (lru_type_map[x] == COLD_LRU && tails[i] != NULL) { age = current_time - tails[i]->time; } else if (lru_type_map[x] == HOT_LRU && tails[i] != NULL) { age_hot = current_time - tails[i]->time; } else if (lru_type_map[x] == WARM_LRU && tails[i] != NULL) { age_warm = current_time - tails[i]->time; } if (lru_type_map[x] == COLD_LRU) totals.evicted_time = itemstats[i].evicted_time; switch (lru_type_map[x]) { case HOT_LRU: totals.hits_to_hot = thread_stats.lru_hits[i]; break; case WARM_LRU: totals.hits_to_warm = thread_stats.lru_hits[i]; break; case COLD_LRU: totals.hits_to_cold = thread_stats.lru_hits[i]; break; case TEMP_LRU: totals.hits_to_temp = thread_stats.lru_hits[i]; break; } pthread_mutex_unlock(&lru_locks[i]); } if (size == 0) continue; APPEND_NUM_FMT_STAT(fmt, n, "number", "%u", size); if (settings.lru_maintainer_thread) { APPEND_NUM_FMT_STAT(fmt, n, "number_hot", "%u", lru_size_map[0]); APPEND_NUM_FMT_STAT(fmt, n, "number_warm", "%u", lru_size_map[1]); APPEND_NUM_FMT_STAT(fmt, n, "number_cold", "%u", lru_size_map[2]); if (settings.temp_lru) { APPEND_NUM_FMT_STAT(fmt, n, "number_temp", "%u", lru_size_map[3]); } APPEND_NUM_FMT_STAT(fmt, n, "age_hot", "%u", age_hot); APPEND_NUM_FMT_STAT(fmt, n, "age_warm", "%u", age_warm); } APPEND_NUM_FMT_STAT(fmt, n, "age", "%u", age); APPEND_NUM_FMT_STAT(fmt, n, "mem_requested", "%llu", (unsigned long long)totals.mem_requested); APPEND_NUM_FMT_STAT(fmt, n, "evicted", "%llu", (unsigned long long)totals.evicted); APPEND_NUM_FMT_STAT(fmt, n, "evicted_nonzero", "%llu", (unsigned long long)totals.evicted_nonzero); APPEND_NUM_FMT_STAT(fmt, n, "evicted_time", "%u", totals.evicted_time); APPEND_NUM_FMT_STAT(fmt, n, "outofmemory", "%llu", (unsigned long long)totals.outofmemory); APPEND_NUM_FMT_STAT(fmt, n, "tailrepairs", "%llu", (unsigned long long)totals.tailrepairs); APPEND_NUM_FMT_STAT(fmt, n, "reclaimed", "%llu", (unsigned long long)totals.reclaimed); APPEND_NUM_FMT_STAT(fmt, n, "expired_unfetched", "%llu", (unsigned long long)totals.expired_unfetched); APPEND_NUM_FMT_STAT(fmt, n, "evicted_unfetched", "%llu", (unsigned long long)totals.evicted_unfetched); if (settings.lru_maintainer_thread) { APPEND_NUM_FMT_STAT(fmt, n, "evicted_active", "%llu", (unsigned long long)totals.evicted_active); } APPEND_NUM_FMT_STAT(fmt, n, "crawler_reclaimed", "%llu", (unsigned long long)totals.crawler_reclaimed); APPEND_NUM_FMT_STAT(fmt, n, "crawler_items_checked", "%llu", (unsigned long long)totals.crawler_items_checked); APPEND_NUM_FMT_STAT(fmt, n, "lrutail_reflocked", "%llu", (unsigned long long)totals.lrutail_reflocked); if (settings.lru_maintainer_thread) { APPEND_NUM_FMT_STAT(fmt, n, "moves_to_cold", "%llu", (unsigned long long)totals.moves_to_cold); APPEND_NUM_FMT_STAT(fmt, n, "moves_to_warm", "%llu", (unsigned long long)totals.moves_to_warm); APPEND_NUM_FMT_STAT(fmt, n, "moves_within_lru", "%llu", (unsigned long long)totals.moves_within_lru); APPEND_NUM_FMT_STAT(fmt, n, "direct_reclaims", "%llu", (unsigned long long)totals.direct_reclaims); APPEND_NUM_FMT_STAT(fmt, n, "hits_to_hot", "%llu", (unsigned long long)totals.hits_to_hot); APPEND_NUM_FMT_STAT(fmt, n, "hits_to_warm", "%llu", (unsigned long long)totals.hits_to_warm); APPEND_NUM_FMT_STAT(fmt, n, "hits_to_cold", "%llu", (unsigned long long)totals.hits_to_cold); APPEND_NUM_FMT_STAT(fmt, n, "hits_to_temp", "%llu", (unsigned long long)totals.hits_to_temp); } } /* getting here means both ascii and binary terminators fit */ add_stats(NULL, 0, NULL, 0, c); } bool item_stats_sizes_status(void) { bool ret = false; mutex_lock(&stats_sizes_lock); if (stats_sizes_hist != NULL) ret = true; mutex_unlock(&stats_sizes_lock); return ret; } void item_stats_sizes_init(void) { if (stats_sizes_hist != NULL) return; stats_sizes_buckets = settings.item_size_max / 32 + 1; stats_sizes_hist = calloc(stats_sizes_buckets, sizeof(int)); stats_sizes_cas_min = (settings.use_cas) ? get_cas_id() : 0; } void item_stats_sizes_enable(ADD_STAT add_stats, void *c) { mutex_lock(&stats_sizes_lock); if (!settings.use_cas) { APPEND_STAT("sizes_status", "error", ""); APPEND_STAT("sizes_error", "cas_support_disabled", ""); } else if (stats_sizes_hist == NULL) { item_stats_sizes_init(); if (stats_sizes_hist != NULL) { APPEND_STAT("sizes_status", "enabled", ""); } else { APPEND_STAT("sizes_status", "error", ""); APPEND_STAT("sizes_error", "no_memory", ""); } } else { APPEND_STAT("sizes_status", "enabled", ""); } mutex_unlock(&stats_sizes_lock); } void item_stats_sizes_disable(ADD_STAT add_stats, void *c) { mutex_lock(&stats_sizes_lock); if (stats_sizes_hist != NULL) { free(stats_sizes_hist); stats_sizes_hist = NULL; } APPEND_STAT("sizes_status", "disabled", ""); mutex_unlock(&stats_sizes_lock); } void item_stats_sizes_add(item *it) { if (stats_sizes_hist == NULL || stats_sizes_cas_min > ITEM_get_cas(it)) return; int ntotal = ITEM_ntotal(it); int bucket = ntotal / 32; if ((ntotal % 32) != 0) bucket++; if (bucket < stats_sizes_buckets) stats_sizes_hist[bucket]++; } /* I think there's no way for this to be accurate without using the CAS value. * Since items getting their time value bumped will pass this validation. */ void item_stats_sizes_remove(item *it) { if (stats_sizes_hist == NULL || stats_sizes_cas_min > ITEM_get_cas(it)) return; int ntotal = ITEM_ntotal(it); int bucket = ntotal / 32; if ((ntotal % 32) != 0) bucket++; if (bucket < stats_sizes_buckets) stats_sizes_hist[bucket]--; } /** dumps out a list of objects of each size, with granularity of 32 bytes */ /*@null@*/ /* Locks are correct based on a technicality. Holds LRU lock while doing the * work, so items can't go invalid, and it's only looking at header sizes * which don't change. */ void item_stats_sizes(ADD_STAT add_stats, void *c) { mutex_lock(&stats_sizes_lock); if (stats_sizes_hist != NULL) { int i; for (i = 0; i < stats_sizes_buckets; i++) { if (stats_sizes_hist[i] != 0) { char key[12]; snprintf(key, sizeof(key), "%d", i * 32); APPEND_STAT(key, "%u", stats_sizes_hist[i]); } } } else { APPEND_STAT("sizes_status", "disabled", ""); } add_stats(NULL, 0, NULL, 0, c); mutex_unlock(&stats_sizes_lock); } /** wrapper around assoc_find which does the lazy expiration logic */ item *do_item_get(const char *key, const size_t nkey, const uint32_t hv, LIBEVENT_THREAD *t, const bool do_update) { item *it = assoc_find(key, nkey, hv); if (it != NULL) { refcount_incr(it); /* Optimization for slab reassignment. prevents popular items from * jamming in busy wait. Can only do this here to satisfy lock order * of item_lock, slabs_lock. */ /* This was made unsafe by removal of the cache_lock: * slab_rebalance_signal and slab_rebal.* are modified in a separate * thread under slabs_lock. If slab_rebalance_signal = 1, slab_start = * NULL (0), but slab_end is still equal to some value, this would end * up unlinking every item fetched. * This is either an acceptable loss, or if slab_rebalance_signal is * true, slab_start/slab_end should be put behind the slabs_lock. * Which would cause a huge potential slowdown. * Could also use a specific lock for slab_rebal.* and * slab_rebalance_signal (shorter lock?) */ /*if (slab_rebalance_signal && ((void *)it >= slab_rebal.slab_start && (void *)it < slab_rebal.slab_end)) { do_item_unlink(it, hv); do_item_remove(it); it = NULL; }*/ } int was_found = 0; if (settings.verbose > 2) { int ii; if (it == NULL) { fprintf(stderr, "> NOT FOUND "); } else if (was_found) { fprintf(stderr, "> FOUND KEY "); } for (ii = 0; ii < nkey; ++ii) { fprintf(stderr, "%c", key[ii]); } } if (it != NULL) { was_found = 1; if (item_is_flushed(it)) { do_item_unlink(it, hv); STORAGE_delete(t->storage, it); do_item_remove(it); it = NULL; pthread_mutex_lock(&t->stats.mutex); t->stats.get_flushed++; pthread_mutex_unlock(&t->stats.mutex); if (settings.verbose > 2) { fprintf(stderr, " -nuked by flush"); } was_found = 2; } else if (it->exptime != 0 && it->exptime <= current_time) { do_item_unlink(it, hv); STORAGE_delete(t->storage, it); do_item_remove(it); it = NULL; pthread_mutex_lock(&t->stats.mutex); t->stats.get_expired++; pthread_mutex_unlock(&t->stats.mutex); if (settings.verbose > 2) { fprintf(stderr, " -nuked by expire"); } was_found = 3; } else { if (do_update) { do_item_bump(t, it, hv); } DEBUG_REFCNT(it, '+'); } } if (settings.verbose > 2) fprintf(stderr, "\n"); /* For now this is in addition to the above verbose logging. */ LOGGER_LOG(t->l, LOG_FETCHERS, LOGGER_ITEM_GET, NULL, was_found, key, nkey, (it) ? it->nbytes : 0, (it) ? ITEM_clsid(it) : 0, t->cur_sfd); return it; } // Requires lock held for item. // Split out of do_item_get() to allow mget functions to look through header // data before losing state modified via the bump function. void do_item_bump(LIBEVENT_THREAD *t, item *it, const uint32_t hv) { /* We update the hit markers only during fetches. * An item needs to be hit twice overall to be considered * ACTIVE, but only needs a single hit to maintain activity * afterward. * FETCHED tells if an item has ever been active. */ if (settings.lru_segmented) { if ((it->it_flags & ITEM_ACTIVE) == 0) { if ((it->it_flags & ITEM_FETCHED) == 0) { it->it_flags |= ITEM_FETCHED; } else { it->it_flags |= ITEM_ACTIVE; if (ITEM_lruid(it) != COLD_LRU) { it->time = current_time; // only need to bump time. } else if (!lru_bump_async(t->lru_bump_buf, it, hv)) { // add flag before async bump to avoid race. it->it_flags &= ~ITEM_ACTIVE; } } } } else { it->it_flags |= ITEM_FETCHED; do_item_update(it); } } item *do_item_touch(const char *key, size_t nkey, uint32_t exptime, const uint32_t hv, LIBEVENT_THREAD *t) { item *it = do_item_get(key, nkey, hv, t, DO_UPDATE); if (it != NULL) { it->exptime = exptime; } return it; } /*** LRU MAINTENANCE THREAD ***/ /* Returns number of items remove, expired, or evicted. * Callable from worker threads or the LRU maintainer thread */ int lru_pull_tail(const int orig_id, const int cur_lru, const uint64_t total_bytes, const uint8_t flags, const rel_time_t max_age, struct lru_pull_tail_return *ret_it) { item *it = NULL; int id = orig_id; int removed = 0; if (id == 0) return 0; int tries = 5; item *search; item *next_it; void *hold_lock = NULL; unsigned int move_to_lru = 0; uint64_t limit = 0; id |= cur_lru; pthread_mutex_lock(&lru_locks[id]); search = tails[id]; /* We walk up *only* for locked items, and if bottom is expired. */ for (; tries > 0 && search != NULL; tries--, search=next_it) { /* we might relink search mid-loop, so search->prev isn't reliable */ next_it = search->prev; if (search->nbytes == 0 && search->nkey == 0 && search->it_flags == 1) { /* We are a crawler, ignore it. */ if (flags & LRU_PULL_CRAWL_BLOCKS) { pthread_mutex_unlock(&lru_locks[id]); return 0; } tries++; continue; } uint32_t hv = hash(ITEM_key(search), search->nkey); /* Attempt to hash item lock the "search" item. If locked, no * other callers can incr the refcount. Also skip ourselves. */ if ((hold_lock = item_trylock(hv)) == NULL) continue; /* Now see if the item is refcount locked */ if (refcount_incr(search) != 2) { /* Note pathological case with ref'ed items in tail. * Can still unlink the item, but it won't be reusable yet */ itemstats[id].lrutail_reflocked++; /* In case of refcount leaks, enable for quick workaround. */ /* WARNING: This can cause terrible corruption */ if (settings.tail_repair_time && search->time + settings.tail_repair_time < current_time) { itemstats[id].tailrepairs++; search->refcount = 1; /* This will call item_remove -> item_free since refcnt is 1 */ STORAGE_delete(ext_storage, search); do_item_unlink_nolock(search, hv); item_trylock_unlock(hold_lock); continue; } } /* Expired or flushed */ if ((search->exptime != 0 && search->exptime < current_time) || item_is_flushed(search)) { itemstats[id].reclaimed++; if ((search->it_flags & ITEM_FETCHED) == 0) { itemstats[id].expired_unfetched++; } /* refcnt 2 -> 1 */ do_item_unlink_nolock(search, hv); STORAGE_delete(ext_storage, search); /* refcnt 1 -> 0 -> item_free */ do_item_remove(search); item_trylock_unlock(hold_lock); removed++; /* If all we're finding are expired, can keep going */ continue; } /* If we're HOT_LRU or WARM_LRU and over size limit, send to COLD_LRU. * If we're COLD_LRU, send to WARM_LRU unless we need to evict */ switch (cur_lru) { case HOT_LRU: limit = total_bytes * settings.hot_lru_pct / 100; case WARM_LRU: if (limit == 0) limit = total_bytes * settings.warm_lru_pct / 100; /* Rescue ACTIVE items aggressively */ if ((search->it_flags & ITEM_ACTIVE) != 0) { search->it_flags &= ~ITEM_ACTIVE; removed++; if (cur_lru == WARM_LRU) { itemstats[id].moves_within_lru++; do_item_unlink_q(search); do_item_link_q(search); do_item_remove(search); item_trylock_unlock(hold_lock); } else { /* Active HOT_LRU items flow to WARM */ itemstats[id].moves_to_warm++; move_to_lru = WARM_LRU; do_item_unlink_q(search); it = search; } } else if (sizes_bytes[id] > limit || current_time - search->time > max_age) { itemstats[id].moves_to_cold++; move_to_lru = COLD_LRU; do_item_unlink_q(search); it = search; removed++; break; } else { /* Don't want to move to COLD, not active, bail out */ it = search; } break; case COLD_LRU: it = search; /* No matter what, we're stopping */ if (flags & LRU_PULL_EVICT) { if (settings.evict_to_free == 0) { /* Don't think we need a counter for this. It'll OOM. */ break; } itemstats[id].evicted++; itemstats[id].evicted_time = current_time - search->time; if (search->exptime != 0) itemstats[id].evicted_nonzero++; if ((search->it_flags & ITEM_FETCHED) == 0) { itemstats[id].evicted_unfetched++; } if ((search->it_flags & ITEM_ACTIVE)) { itemstats[id].evicted_active++; } LOGGER_LOG(NULL, LOG_EVICTIONS, LOGGER_EVICTION, search); STORAGE_delete(ext_storage, search); do_item_unlink_nolock(search, hv); removed++; if (settings.slab_automove == 2) { slabs_reassign(-1, orig_id); } } else if (flags & LRU_PULL_RETURN_ITEM) { /* Keep a reference to this item and return it. */ ret_it->it = it; ret_it->hv = hv; } else if ((search->it_flags & ITEM_ACTIVE) != 0 && settings.lru_segmented) { itemstats[id].moves_to_warm++; search->it_flags &= ~ITEM_ACTIVE; move_to_lru = WARM_LRU; do_item_unlink_q(search); removed++; } break; case TEMP_LRU: it = search; /* Kill the loop. Parent only interested in reclaims */ break; } if (it != NULL) break; } pthread_mutex_unlock(&lru_locks[id]); if (it != NULL) { if (move_to_lru) { it->slabs_clsid = ITEM_clsid(it); it->slabs_clsid |= move_to_lru; item_link_q(it); } if ((flags & LRU_PULL_RETURN_ITEM) == 0) { do_item_remove(it); item_trylock_unlock(hold_lock); } } return removed; } /* TODO: Third place this code needs to be deduped */ static void lru_bump_buf_link_q(lru_bump_buf *b) { pthread_mutex_lock(&bump_buf_lock); assert(b != bump_buf_head); b->prev = 0; b->next = bump_buf_head; if (b->next) b->next->prev = b; bump_buf_head = b; if (bump_buf_tail == 0) bump_buf_tail = b; pthread_mutex_unlock(&bump_buf_lock); return; } void *item_lru_bump_buf_create(void) { lru_bump_buf *b = calloc(1, sizeof(lru_bump_buf)); if (b == NULL) { return NULL; } b->buf = bipbuf_new(sizeof(lru_bump_entry) * LRU_BUMP_BUF_SIZE); if (b->buf == NULL) { free(b); return NULL; } pthread_mutex_init(&b->mutex, NULL); lru_bump_buf_link_q(b); return b; } static bool lru_bump_async(lru_bump_buf *b, item *it, uint32_t hv) { bool ret = true; refcount_incr(it); pthread_mutex_lock(&b->mutex); lru_bump_entry *be = (lru_bump_entry *) bipbuf_request(b->buf, sizeof(lru_bump_entry)); if (be != NULL) { be->it = it; be->hv = hv; if (bipbuf_push(b->buf, sizeof(lru_bump_entry)) == 0) { ret = false; b->dropped++; } } else { ret = false; b->dropped++; } if (!ret) { refcount_decr(it); } pthread_mutex_unlock(&b->mutex); return ret; } /* TODO: Might be worth a micro-optimization of having bump buffers link * themselves back into the central queue when queue goes from zero to * non-zero, then remove from list if zero more than N times. * If very few hits on cold this would avoid extra memory barriers from LRU * maintainer thread. If many hits, they'll just stay in the list. */ static bool lru_maintainer_bumps(void) { lru_bump_buf *b; lru_bump_entry *be; unsigned int size; unsigned int todo; bool bumped = false; pthread_mutex_lock(&bump_buf_lock); for (b = bump_buf_head; b != NULL; b=b->next) { pthread_mutex_lock(&b->mutex); be = (lru_bump_entry *) bipbuf_peek_all(b->buf, &size); pthread_mutex_unlock(&b->mutex); if (be == NULL) { continue; } todo = size; bumped = true; while (todo) { item_lock(be->hv); do_item_update(be->it); do_item_remove(be->it); item_unlock(be->hv); be++; todo -= sizeof(lru_bump_entry); } pthread_mutex_lock(&b->mutex); be = (lru_bump_entry *) bipbuf_poll(b->buf, size); pthread_mutex_unlock(&b->mutex); } pthread_mutex_unlock(&bump_buf_lock); return bumped; } static uint64_t lru_total_bumps_dropped(void) { uint64_t total = 0; lru_bump_buf *b; pthread_mutex_lock(&bump_buf_lock); for (b = bump_buf_head; b != NULL; b=b->next) { pthread_mutex_lock(&b->mutex); total += b->dropped; pthread_mutex_unlock(&b->mutex); } pthread_mutex_unlock(&bump_buf_lock); return total; } /* Loop up to N times: * If too many items are in HOT_LRU, push to COLD_LRU * If too many items are in WARM_LRU, push to COLD_LRU * If too many items are in COLD_LRU, poke COLD_LRU tail * 1000 loops with 1ms min sleep gives us under 1m items shifted/sec. The * locks can't handle much more than that. Leaving a TODO for how to * autoadjust in the future. */ static int lru_maintainer_juggle(const int slabs_clsid) { int i; int did_moves = 0; uint64_t total_bytes = 0; unsigned int chunks_perslab = 0; //unsigned int chunks_free = 0; /* TODO: if free_chunks below high watermark, increase aggressiveness */ slabs_available_chunks(slabs_clsid, NULL, &chunks_perslab); if (settings.temp_lru) { /* Only looking for reclaims. Run before we size the LRU. */ for (i = 0; i < 500; i++) { if (lru_pull_tail(slabs_clsid, TEMP_LRU, 0, 0, 0, NULL) <= 0) { break; } else { did_moves++; } } } rel_time_t cold_age = 0; rel_time_t hot_age = 0; rel_time_t warm_age = 0; /* If LRU is in flat mode, force items to drain into COLD via max age of 0 */ if (settings.lru_segmented) { pthread_mutex_lock(&lru_locks[slabs_clsid|COLD_LRU]); if (tails[slabs_clsid|COLD_LRU]) { cold_age = current_time - tails[slabs_clsid|COLD_LRU]->time; } // Also build up total_bytes for the classes. total_bytes += sizes_bytes[slabs_clsid|COLD_LRU]; pthread_mutex_unlock(&lru_locks[slabs_clsid|COLD_LRU]); hot_age = cold_age * settings.hot_max_factor; warm_age = cold_age * settings.warm_max_factor; // total_bytes doesn't have to be exact. cache it for the juggles. pthread_mutex_lock(&lru_locks[slabs_clsid|HOT_LRU]); total_bytes += sizes_bytes[slabs_clsid|HOT_LRU]; pthread_mutex_unlock(&lru_locks[slabs_clsid|HOT_LRU]); pthread_mutex_lock(&lru_locks[slabs_clsid|WARM_LRU]); total_bytes += sizes_bytes[slabs_clsid|WARM_LRU]; pthread_mutex_unlock(&lru_locks[slabs_clsid|WARM_LRU]); } /* Juggle HOT/WARM up to N times */ for (i = 0; i < 500; i++) { int do_more = 0; if (lru_pull_tail(slabs_clsid, HOT_LRU, total_bytes, LRU_PULL_CRAWL_BLOCKS, hot_age, NULL) || lru_pull_tail(slabs_clsid, WARM_LRU, total_bytes, LRU_PULL_CRAWL_BLOCKS, warm_age, NULL)) { do_more++; } if (settings.lru_segmented) { do_more += lru_pull_tail(slabs_clsid, COLD_LRU, total_bytes, LRU_PULL_CRAWL_BLOCKS, 0, NULL); } if (do_more == 0) break; did_moves++; } return did_moves; } /* Will crawl all slab classes a minimum of once per hour */ #define MAX_MAINTCRAWL_WAIT 60 * 60 /* Hoping user input will improve this function. This is all a wild guess. * Operation: Kicks crawler for each slab id. Crawlers take some statistics as * to items with nonzero expirations. It then buckets how many items will * expire per minute for the next hour. * This function checks the results of a run, and if it things more than 1% of * expirable objects are ready to go, kick the crawler again to reap. * It will also kick the crawler once per minute regardless, waiting a minute * longer for each time it has no work to do, up to an hour wait time. * The latter is to avoid newly started daemons from waiting too long before * retrying a crawl. */ static void lru_maintainer_crawler_check(struct crawler_expired_data *cdata, logger *l) { int i; static rel_time_t next_crawls[POWER_LARGEST]; static rel_time_t next_crawl_wait[POWER_LARGEST]; uint8_t todo[POWER_LARGEST]; memset(todo, 0, sizeof(uint8_t) * POWER_LARGEST); bool do_run = false; unsigned int tocrawl_limit = 0; // TODO: If not segmented LRU, skip non-cold for (i = POWER_SMALLEST; i < POWER_LARGEST; i++) { crawlerstats_t *s = &cdata->crawlerstats[i]; /* We've not successfully kicked off a crawl yet. */ if (s->run_complete) { char *lru_name = "na"; pthread_mutex_lock(&cdata->lock); int x; /* Should we crawl again? */ uint64_t possible_reclaims = s->seen - s->noexp; uint64_t available_reclaims = 0; /* Need to think we can free at least 1% of the items before * crawling. */ /* FIXME: Configurable? */ uint64_t low_watermark = (possible_reclaims / 100) + 1; rel_time_t since_run = current_time - s->end_time; /* Don't bother if the payoff is too low. */ for (x = 0; x < 60; x++) { available_reclaims += s->histo[x]; if (available_reclaims > low_watermark) { if (next_crawl_wait[i] < (x * 60)) { next_crawl_wait[i] += 60; } else if (next_crawl_wait[i] >= 60) { next_crawl_wait[i] -= 60; } break; } } if (available_reclaims == 0) { next_crawl_wait[i] += 60; } if (next_crawl_wait[i] > MAX_MAINTCRAWL_WAIT) { next_crawl_wait[i] = MAX_MAINTCRAWL_WAIT; } next_crawls[i] = current_time + next_crawl_wait[i] + 5; switch (GET_LRU(i)) { case HOT_LRU: lru_name = "hot"; break; case WARM_LRU: lru_name = "warm"; break; case COLD_LRU: lru_name = "cold"; break; case TEMP_LRU: lru_name = "temp"; break; } LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_CRAWLER_STATUS, NULL, CLEAR_LRU(i), lru_name, (unsigned long long)low_watermark, (unsigned long long)available_reclaims, (unsigned int)since_run, next_crawls[i] - current_time, s->end_time - s->start_time, s->seen, s->reclaimed); // Got our calculation, avoid running until next actual run. s->run_complete = false; pthread_mutex_unlock(&cdata->lock); } if (current_time > next_crawls[i]) { pthread_mutex_lock(&lru_locks[i]); if (sizes[i] > tocrawl_limit) { tocrawl_limit = sizes[i]; } pthread_mutex_unlock(&lru_locks[i]); todo[i] = 1; do_run = true; next_crawls[i] = current_time + 5; // minimum retry wait. } } if (do_run) { if (settings.lru_crawler_tocrawl && settings.lru_crawler_tocrawl < tocrawl_limit) { tocrawl_limit = settings.lru_crawler_tocrawl; } lru_crawler_start(todo, tocrawl_limit, CRAWLER_AUTOEXPIRE, cdata, NULL, 0); } } slab_automove_reg_t slab_automove_default = { .init = slab_automove_init, .free = slab_automove_free, .run = slab_automove_run }; #ifdef EXTSTORE slab_automove_reg_t slab_automove_extstore = { .init = slab_automove_extstore_init, .free = slab_automove_extstore_free, .run = slab_automove_extstore_run }; #endif static pthread_t lru_maintainer_tid; #define MAX_LRU_MAINTAINER_SLEEP 1000000 #define MIN_LRU_MAINTAINER_SLEEP 1000 static void *lru_maintainer_thread(void *arg) { slab_automove_reg_t *sam = &slab_automove_default; #ifdef EXTSTORE void *storage = arg; if (storage != NULL) sam = &slab_automove_extstore; #endif int i; useconds_t to_sleep = MIN_LRU_MAINTAINER_SLEEP; useconds_t last_sleep = MIN_LRU_MAINTAINER_SLEEP; rel_time_t last_crawler_check = 0; rel_time_t last_automove_check = 0; useconds_t next_juggles[MAX_NUMBER_OF_SLAB_CLASSES] = {0}; useconds_t backoff_juggles[MAX_NUMBER_OF_SLAB_CLASSES] = {0}; struct crawler_expired_data *cdata = calloc(1, sizeof(struct crawler_expired_data)); if (cdata == NULL) { fprintf(stderr, "Failed to allocate crawler data for LRU maintainer thread\n"); abort(); } pthread_mutex_init(&cdata->lock, NULL); cdata->crawl_complete = true; // kick off the crawler. logger *l = logger_create(); if (l == NULL) { fprintf(stderr, "Failed to allocate logger for LRU maintainer thread\n"); abort(); } double last_ratio = settings.slab_automove_ratio; void *am = sam->init(&settings); pthread_mutex_lock(&lru_maintainer_lock); if (settings.verbose > 2) fprintf(stderr, "Starting LRU maintainer background thread\n"); while (do_run_lru_maintainer_thread) { pthread_mutex_unlock(&lru_maintainer_lock); if (to_sleep) usleep(to_sleep); pthread_mutex_lock(&lru_maintainer_lock); /* A sleep of zero counts as a minimum of a 1ms wait */ last_sleep = to_sleep > 1000 ? to_sleep : 1000; to_sleep = MAX_LRU_MAINTAINER_SLEEP; STATS_LOCK(); stats.lru_maintainer_juggles++; STATS_UNLOCK(); /* Each slab class gets its own sleep to avoid hammering locks */ for (i = POWER_SMALLEST; i < MAX_NUMBER_OF_SLAB_CLASSES; i++) { next_juggles[i] = next_juggles[i] > last_sleep ? next_juggles[i] - last_sleep : 0; if (next_juggles[i] > 0) { // Sleep the thread just for the minimum amount (or not at all) if (next_juggles[i] < to_sleep) to_sleep = next_juggles[i]; continue; } int did_moves = lru_maintainer_juggle(i); if (did_moves == 0) { if (backoff_juggles[i] != 0) { backoff_juggles[i] += backoff_juggles[i] / 8; } else { backoff_juggles[i] = MIN_LRU_MAINTAINER_SLEEP; } if (backoff_juggles[i] > MAX_LRU_MAINTAINER_SLEEP) backoff_juggles[i] = MAX_LRU_MAINTAINER_SLEEP; } else if (backoff_juggles[i] > 0) { backoff_juggles[i] /= 2; if (backoff_juggles[i] < MIN_LRU_MAINTAINER_SLEEP) { backoff_juggles[i] = 0; } } next_juggles[i] = backoff_juggles[i]; if (next_juggles[i] < to_sleep) to_sleep = next_juggles[i]; } /* Minimize the sleep if we had async LRU bumps to process */ if (settings.lru_segmented && lru_maintainer_bumps() && to_sleep > 1000) { to_sleep = 1000; } /* Once per second at most */ if (settings.lru_crawler && last_crawler_check != current_time) { lru_maintainer_crawler_check(cdata, l); last_crawler_check = current_time; } if (settings.slab_automove == 1 && last_automove_check != current_time) { if (last_ratio != settings.slab_automove_ratio) { sam->free(am); am = sam->init(&settings); last_ratio = settings.slab_automove_ratio; } int src, dst; sam->run(am, &src, &dst); if (src != -1 && dst != -1) { slabs_reassign(src, dst); LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_SLAB_MOVE, NULL, src, dst); } // dst == 0 means reclaim to global pool, be more aggressive if (dst != 0) { last_automove_check = current_time; } else if (dst == 0) { // also ensure we minimize the thread sleep to_sleep = 1000; } } } pthread_mutex_unlock(&lru_maintainer_lock); sam->free(am); // LRU crawler *must* be stopped. free(cdata); if (settings.verbose > 2) fprintf(stderr, "LRU maintainer thread stopping\n"); return NULL; } int stop_lru_maintainer_thread(void) { int ret; pthread_mutex_lock(&lru_maintainer_lock); /* LRU thread is a sleep loop, will die on its own */ do_run_lru_maintainer_thread = 0; pthread_mutex_unlock(&lru_maintainer_lock); if ((ret = pthread_join(lru_maintainer_tid, NULL)) != 0) { fprintf(stderr, "Failed to stop LRU maintainer thread: %s\n", strerror(ret)); return -1; } settings.lru_maintainer_thread = false; return 0; } int start_lru_maintainer_thread(void *arg) { int ret; pthread_mutex_lock(&lru_maintainer_lock); do_run_lru_maintainer_thread = 1; settings.lru_maintainer_thread = true; if ((ret = pthread_create(&lru_maintainer_tid, NULL, lru_maintainer_thread, arg)) != 0) { fprintf(stderr, "Can't create LRU maintainer thread: %s\n", strerror(ret)); pthread_mutex_unlock(&lru_maintainer_lock); return -1; } thread_setname(lru_maintainer_tid, "mc-lrumaint"); pthread_mutex_unlock(&lru_maintainer_lock); return 0; } /* If we hold this lock, crawler can't wake up or move */ void lru_maintainer_pause(void) { pthread_mutex_lock(&lru_maintainer_lock); } void lru_maintainer_resume(void) { pthread_mutex_unlock(&lru_maintainer_lock); } /* Tail linkers and crawler for the LRU crawler. */ void do_item_linktail_q(item *it) { /* item is the new tail */ item **head, **tail; assert(it->it_flags == 1); assert(it->nbytes == 0); head = &heads[it->slabs_clsid]; tail = &tails[it->slabs_clsid]; //assert(*tail != 0); assert(it != *tail); assert((*head && *tail) || (*head == 0 && *tail == 0)); it->prev = *tail; it->next = 0; if (it->prev) { assert(it->prev->next == 0); it->prev->next = it; } *tail = it; if (*head == 0) *head = it; return; } void do_item_unlinktail_q(item *it) { item **head, **tail; head = &heads[it->slabs_clsid]; tail = &tails[it->slabs_clsid]; if (*head == it) { assert(it->prev == 0); *head = it->next; } if (*tail == it) { assert(it->next == 0); *tail = it->prev; } assert(it->next != it); assert(it->prev != it); if (it->next) it->next->prev = it->prev; if (it->prev) it->prev->next = it->next; return; } /* This is too convoluted, but it's a difficult shuffle. Try to rewrite it * more clearly. */ item *do_item_crawl_q(item *it) { item **head, **tail; assert(it->it_flags == 1); assert(it->nbytes == 0); head = &heads[it->slabs_clsid]; tail = &tails[it->slabs_clsid]; /* We've hit the head, pop off */ if (it->prev == 0) { assert(*head == it); if (it->next) { *head = it->next; assert(it->next->prev == it); it->next->prev = 0; } return NULL; /* Done */ } /* Swing ourselves in front of the next item */ /* NB: If there is a prev, we can't be the head */ assert(it->prev != it); if (it->prev) { if (*head == it->prev) { /* Prev was the head, now we're the head */ *head = it; } if (*tail == it) { /* We are the tail, now they are the tail */ *tail = it->prev; } assert(it->next != it); if (it->next) { assert(it->prev->next == it); it->prev->next = it->next; it->next->prev = it->prev; } else { /* Tail. Move this above? */ it->prev->next = 0; } /* prev->prev's next is it->prev */ it->next = it->prev; it->prev = it->next->prev; it->next->prev = it; /* New it->prev now, if we're not at the head. */ if (it->prev) { it->prev->next = it; } } assert(it->next != it); assert(it->prev != it); return it->next; /* success */ } memcached-1.6.20/restart.h0000664000175000017500000000153314204760331012270 00000000000000#ifndef RESTART_H #define RESTART_H #define RESTART_TAG_MAXLEN 255 // Track the pointer size for restart fiddling. #if SIZEOF_VOID_P == 8 typedef uint64_t mc_ptr_t; #else typedef uint32_t mc_ptr_t; #endif enum restart_get_kv_ret { RESTART_OK=0, RESTART_NOTAG, RESTART_BADLINE, RESTART_DONE }; typedef int (*restart_check_cb)(const char *tag, void *ctx, void *data); typedef int (*restart_save_cb)(const char *tag, void *ctx, void *data); void restart_register(const char *tag, restart_check_cb ccb, restart_save_cb scb, void *data); void restart_set_kv(void *ctx, const char *key, const char *fmt, ...); enum restart_get_kv_ret restart_get_kv(void *ctx, char **key, char **val); bool restart_mmap_open(const size_t limit, const char *file, void **mem_base); void restart_mmap_close(void); unsigned int restart_fixup(void *old_base); #endif memcached-1.6.20/base64.h0000664000175000017500000000074714302037501011671 00000000000000/* * Base64 encoding/decoding (RFC1341) * Copyright (c) 2005, Jouni Malinen * * This software may be distributed under the terms of the BSD license. * See base64.c for more details */ #ifndef BASE64_H #define BASE64_H size_t base64_encode(const unsigned char *src, size_t len, unsigned char *out, size_t out_len); size_t base64_decode(const unsigned char *src, size_t len, unsigned char *out, size_t out_len); #endif /* BASE64_H */ memcached-1.6.20/hash.c0000664000175000017500000000154114302037501011514 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "memcached.h" #include "jenkins_hash.h" #include "murmur3_hash.h" #define XXH_INLINE_ALL // modifier for xxh3's include below #include "xxhash.h" hash_func hash; static uint32_t XXH3_hash(const void *key, size_t length) { return (uint32_t)XXH3_64bits(key, length); } int hash_init(enum hashfunc_type type) { switch(type) { case JENKINS_HASH: hash = jenkins_hash; settings.hash_algorithm = "jenkins"; break; case MURMUR3_HASH: hash = MurmurHash3_x86_32; settings.hash_algorithm = "murmur3"; break; case XXH3_HASH: hash = XXH3_hash; settings.hash_algorithm = "xxh3"; break; default: return -1; } return 0; } memcached-1.6.20/proxy_request.c0000664000175000017500000006232414427543277013554 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "proxy.h" #define PARSER_MAXLEN USHRT_MAX-1 // Find the starting offsets of each token; ignoring length. // This creates a fast small (<= cacheline) index into the request, // where we later scan or directly feed data into API's. static int _process_tokenize(mcp_parser_t *pr, const size_t max) { const char *s = pr->request; int len = pr->reqlen - 2; // since multigets can be huge, we can't purely judge reqlen against this // limit, but we also can't index past it since the tokens are shorts. if (len > PARSER_MAXLEN) { len = PARSER_MAXLEN; } const char *end = s + len; int curtoken = 0; int state = 0; while (s != end) { switch (state) { case 0: // scanning for first non-space to find a token. if (*s != ' ') { pr->tokens[curtoken] = s - pr->request; if (++curtoken == max) { s++; state = 2; break; } state = 1; } s++; break; case 1: // advance over a token if (*s != ' ') { s++; } else { state = 0; } break; case 2: // hit max tokens before end of the line. // keep advancing so we can place endcap token. if (*s == ' ') { goto endloop; } s++; break; } } endloop: // endcap token so we can quickly find the length of any token by looking // at the next one. pr->tokens[curtoken] = s - pr->request; pr->ntokens = curtoken; P_DEBUG("%s: cur_tokens: %d\n", __func__, curtoken); return 0; } static int _process_token_len(mcp_parser_t *pr, size_t token) { const char *s = pr->request + pr->tokens[token]; const char *e = pr->request + pr->tokens[token+1]; // start of next token is after any space delimiters, so back those out. while (*(e-1) == ' ') { e--; } return e - s; } static int _process_request_key(mcp_parser_t *pr) { pr->klen = _process_token_len(pr, pr->keytoken); // advance the parser in case of multikey. pr->parsed = pr->tokens[pr->keytoken] + pr->klen + 1; if (pr->request[pr->parsed-1] == ' ') { P_DEBUG("%s: request_key found extra space\n", __func__); pr->has_space = true; } else { pr->has_space = false; } return 0; } // Just for ascii multiget: search for next "key" beyond where we stopped // tokenizing before. // Returns the offset for the next key. size_t _process_request_next_key(mcp_parser_t *pr) { const char *cur = pr->request + pr->parsed; int remain = pr->reqlen - pr->parsed - 2; // chew off any leading whitespace. while (remain) { if (*cur == ' ') { remain--; cur++; pr->parsed++; } else { break; } } const char *s = memchr(cur, ' ', remain); if (s != NULL) { pr->klen = s - cur; pr->parsed += s - cur; } else { pr->klen = remain; pr->parsed += remain; } return cur - pr->request; } // for fast testing of existence of meta flags. // meta has all flags as final tokens static int _process_request_metaflags(mcp_parser_t *pr, int token) { if (pr->ntokens <= token) { pr->t.meta.flags = 0; // no flags found. return 0; } const char *cur = pr->request + pr->tokens[token]; const char *end = pr->request + pr->reqlen - 2; // We blindly convert flags into bits, since the range of possible // flags is deliberately < 64. int state = 0; while (cur != end) { switch (state) { case 0: if (*cur == ' ') { cur++; } else { if (*cur < 65 || *cur > 122) { return -1; } P_DEBUG("%s: setting meta flag: %d\n", __func__, *cur - 65); pr->t.meta.flags |= (uint64_t)1 << (*cur - 65); state = 1; } break; case 1: if (*cur != ' ') { cur++; } else { state = 0; } break; } } // not too great hack for noreply detection: this can be flattened out // once a few other contexts are fixed and we detect the noreply from the // coroutine start instead. if (pr->t.meta.flags & ((uint64_t)1 << 48)) { pr->noreply = true; } return 0; } // All meta commands are of form: "cm key f l a g S100" static int _process_request_meta(mcp_parser_t *pr) { _process_tokenize(pr, PARSER_MAX_TOKENS); if (pr->ntokens < 2) { P_DEBUG("%s: not enough tokens for meta command: %d\n", __func__, pr->ntokens); return -1; } pr->keytoken = 1; _process_request_key(pr); // pass the first flag token. return _process_request_metaflags(pr, 2); } // ms *\r\n static int _process_request_mset(mcp_parser_t *pr) { _process_tokenize(pr, PARSER_MAX_TOKENS); if (pr->ntokens < 3) { P_DEBUG("%s: not enough tokens for meta set command: %d\n", __func__, pr->ntokens); return -1; } pr->keytoken = 1; _process_request_key(pr); const char *cur = pr->request + pr->tokens[2]; errno = 0; char *n = NULL; int vlen = strtol(cur, &n, 10); if ((errno == ERANGE) || (cur == n)) { return -1; } if (vlen < 0 || vlen > (INT_MAX - 2)) { return -1; } vlen += 2; pr->vlen = vlen; // pass the first flag token return _process_request_metaflags(pr, 3); } // gat[s] *\r\n static int _process_request_gat(mcp_parser_t *pr) { _process_tokenize(pr, 3); if (pr->ntokens < 3) { P_DEBUG("%s: not enough tokens for GAT: %d\n", __func__, pr->ntokens); return -1; } pr->keytoken = 2; _process_request_key(pr); return 0; } #define NOREPLYSTR "noreply" #define NOREPLYLEN sizeof(NOREPLYSTR)-1 // given a tokenized parser for a normal ASCII command, checks for noreply // mode. static int _process_request_noreply(mcp_parser_t *pr) { if (pr->tokens[pr->ntokens] - pr->tokens[pr->ntokens-1] >= NOREPLYLEN && strncmp(NOREPLYSTR, pr->request + pr->tokens[pr->ntokens-1], NOREPLYLEN) == 0) { pr->noreply = true; } return 0; } // we need t find the bytes supplied immediately so we can read the request // from the client properly. // set [noreply]\r\n static int _process_request_storage(mcp_parser_t *pr, size_t max) { _process_tokenize(pr, max); if (pr->ntokens < 5) { P_DEBUG("%s: not enough tokens to storage command: %d\n", __func__, pr->ntokens); return -1; } pr->keytoken = 1; _process_request_key(pr); errno = 0; char *n = NULL; const char *cur = pr->request + pr->tokens[4]; int vlen = strtol(cur, &n, 10); if ((errno == ERANGE) || (cur == n)) { return -1; } if (vlen < 0 || vlen > (INT_MAX - 2)) { return -1; } vlen += 2; pr->vlen = vlen; return _process_request_noreply(pr); } // common request with key: static int _process_request_simple(mcp_parser_t *pr, const size_t max) { _process_tokenize(pr, max); pr->keytoken = 1; // second token is usually the key... stupid GAT. _process_request_key(pr); return _process_request_noreply(pr); } // TODO: return code ENUM with error types. // FIXME: the mcp_parser_t bits have ended up being more fragile than I hoped. // careful zero'ing is required. revisit? // I think this mostly refers to recursive work (maybe just multiget?) // Is a parser object run throgh process_request() twice, ever? int process_request(mcp_parser_t *pr, const char *command, size_t cmdlen) { // we want to "parse in place" as much as possible, which allows us to // forward an unmodified request without having to rebuild it. const char *cm = command; size_t cl = 0; // min command length is 2, plus the "\r\n" if (cmdlen < 4) { return -1; } const char *s = memchr(command, ' ', cmdlen-2); if (s != NULL) { cl = s - command; } else { cl = cmdlen - 2; } pr->keytoken = 0; pr->has_space = false; pr->parsed = cl + 1; pr->request = command; pr->reqlen = cmdlen; int token_max = PARSER_MAX_TOKENS; int cmd = -1; int type = CMD_TYPE_GENERIC; int ret = 0; switch (cl) { case 0: case 1: // falls through with cmd as -1. should error. break; case 2: if (cm[0] == 'm') { type = CMD_TYPE_META; switch (cm[1]) { case 'g': cmd = CMD_MG; ret = _process_request_meta(pr); break; case 's': cmd = CMD_MS; ret = _process_request_mset(pr); break; case 'd': cmd = CMD_MD; ret = _process_request_meta(pr); break; case 'n': // TODO: do we route/handle NOP's at all? // they should simply reflect to the client. cmd = CMD_MN; break; case 'a': cmd = CMD_MA; ret = _process_request_meta(pr); break; case 'e': cmd = CMD_ME; // TODO: not much special processing here; binary keys ret = _process_request_meta(pr); break; } } break; case 3: if (cm[0] == 'g') { if (cm[1] == 'e' && cm[2] == 't') { cmd = CMD_GET; type = CMD_TYPE_GET; token_max = 2; // don't chew through multigets. ret = _process_request_simple(pr, 2); } if (cm[1] == 'a' && cm[2] == 't') { type = CMD_TYPE_GET; cmd = CMD_GAT; token_max = 2; // don't chew through multigets. ret = _process_request_gat(pr); } } else if (cm[0] == 's' && cm[1] == 'e' && cm[2] == 't') { cmd = CMD_SET; ret = _process_request_storage(pr, token_max); } else if (cm[0] == 'a' && cm[1] == 'd' && cm[2] == 'd') { cmd = CMD_ADD; ret = _process_request_storage(pr, token_max); } else if (cm[0] == 'c' && cm[1] == 'a' && cm[2] == 's') { cmd = CMD_CAS; ret = _process_request_storage(pr, token_max); } break; case 4: if (strncmp(cm, "gets", 4) == 0) { cmd = CMD_GETS; type = CMD_TYPE_GET; token_max = 2; // don't chew through multigets. ret = _process_request_simple(pr, 2); } else if (strncmp(cm, "incr", 4) == 0) { cmd = CMD_INCR; ret = _process_request_simple(pr, 4); } else if (strncmp(cm, "decr", 4) == 0) { cmd = CMD_DECR; ret = _process_request_simple(pr, 4); } else if (strncmp(cm, "gats", 4) == 0) { cmd = CMD_GATS; type = CMD_TYPE_GET; ret = _process_request_gat(pr); } else if (strncmp(cm, "quit", 4) == 0) { cmd = CMD_QUIT; } break; case 5: if (strncmp(cm, "touch", 5) == 0) { cmd = CMD_TOUCH; ret = _process_request_simple(pr, 4); } else if (strncmp(cm, "stats", 5) == 0) { cmd = CMD_STATS; // Don't process a key; fetch via arguments. _process_tokenize(pr, token_max); } else if (strncmp(cm, "watch", 5) == 0) { cmd = CMD_WATCH; _process_tokenize(pr, token_max); } break; case 6: if (strncmp(cm, "delete", 6) == 0) { cmd = CMD_DELETE; ret = _process_request_simple(pr, 4); } else if (strncmp(cm, "append", 6) == 0) { cmd = CMD_APPEND; ret = _process_request_storage(pr, token_max); } break; case 7: if (strncmp(cm, "replace", 7) == 0) { cmd = CMD_REPLACE; ret = _process_request_storage(pr, token_max); } else if (strncmp(cm, "prepend", 7) == 0) { cmd = CMD_PREPEND; ret = _process_request_storage(pr, token_max); } else if (strncmp(cm, "version", 7) == 0) { cmd = CMD_VERSION; _process_tokenize(pr, token_max); } break; } // TODO: log more specific error code. if (cmd == -1 || ret != 0) { return -1; } pr->command = cmd; pr->cmd_type = type; return 0; } // FIXME (v2): any reason to pass in command/cmdlen separately? mcp_request_t *mcp_new_request(lua_State *L, mcp_parser_t *pr, const char *command, size_t cmdlen) { // reserving an upvalue for key. mcp_request_t *rq = lua_newuserdatauv(L, sizeof(mcp_request_t) + MCP_REQUEST_MAXLEN + KEY_MAX_LENGTH, 1); // TODO (v2): memset only the non-data part? as the rest gets memcpy'd // over. memset(rq, 0, sizeof(mcp_request_t)); memcpy(&rq->pr, pr, sizeof(*pr)); memcpy(rq->request, command, cmdlen); rq->pr.request = rq->request; rq->pr.reqlen = cmdlen; luaL_getmetatable(L, "mcp.request"); lua_setmetatable(L, -2); // at this point we should know if we have to bounce through _nread to // get item data or not. return rq; } // Replaces a token inside a request and re-parses. // Note that this has some optimization opportunities. Delaying until // required. // We should not guarantee order when updating meta flags, which would allow // blanking tokens and appending new ones. // TODO (v2): function doesn't allow appending. // TODO (v2): much of the length is the key, avoid copying it. int mcp_request_render(mcp_request_t *rq, int idx, const char *tok, size_t len) { char temp[MCP_REQUEST_MAXLEN]; char *p = temp; mcp_parser_t *pr = &rq->pr; if (pr->reqlen + len > MCP_REQUEST_MAXLEN) { return -1; } // Cannot add/append tokens yet. if (idx >= pr->ntokens) { return -1; } memcpy(p, pr->request, pr->tokens[idx]); p += pr->tokens[idx]; memcpy(p, tok, len); p += len; // Add a space and copy more tokens if there were more. if (idx+1 < pr->ntokens) { if (len != 0) { // Only pre-space if not deleting the token. *p = ' '; p++; } memcpy(p, &pr->request[pr->tokens[idx+1]], pr->tokens[pr->ntokens] - pr->tokens[idx+1]); p += pr->tokens[pr->ntokens] - pr->tokens[idx+1]; } memcpy(p, "\r\n\0", 3); p += 2; memcpy(rq->request, temp, p - temp); // Hold the vlen/vbuf and restore after re-parsing. Since we can only edit // the command line, not the value here, we would otherwise allow sending // arbitrary memory over the network if someone modifies a SET. void *vbuf = pr->vbuf; int vlen = pr->vlen; memset(pr, 0, sizeof(mcp_parser_t)); // TODO: required? int ret = process_request(pr, rq->request, p - temp); if (ret != 0) { return ret; } pr->vbuf = vbuf; pr->vlen = vlen; return 0; } void mcp_request_attach(lua_State *L, mcp_request_t *rq, io_pending_proxy_t *p) { mcp_parser_t *pr = &rq->pr; char *r = (char *) pr->request; size_t len = pr->reqlen; // The stringified request. This is also referencing into the coroutine // stack, which should be safe from gc. p->iov[0].iov_base = r; p->iov[0].iov_len = len; p->iovcnt = 1; p->iovbytes = len; if (pr->vlen != 0) { p->iov[1].iov_base = pr->vbuf; p->iov[1].iov_len = pr->vlen; p->iovcnt = 2; p->iovbytes += pr->vlen; } } // second argument is optional, for building set requests. // TODO: append the \r\n for the VAL? int mcplib_request(lua_State *L) { LIBEVENT_THREAD *t = PROXY_GET_THR(L); size_t len = 0; size_t vlen = 0; mcp_parser_t pr = {0}; const char *cmd = luaL_checklstring(L, 1, &len); const char *val = NULL; int type = lua_type(L, 2); if (type == LUA_TSTRING) { val = luaL_optlstring(L, 2, NULL, &vlen); if (vlen < 2 || memcmp(val+vlen-2, "\r\n", 2) != 0) { proxy_lua_error(L, "value passed to mcp.request must end with \\r\\n"); } } else if (type == LUA_TUSERDATA) { // vlen for requests and responses include the "\r\n" already. mcp_resp_t *r = luaL_testudata(L, 2, "mcp.response"); if (r != NULL) { if (r->resp.value) { val = r->resp.value; vlen = r->resp.vlen_read; // paranoia, so we can't overread into memory. } } else { mcp_request_t *rq = luaL_testudata(L, 2, "mcp.request"); if (rq->pr.vbuf) { val = rq->pr.vbuf; vlen = rq->pr.vlen; } } } // FIXME (v2): if we inline the userdata we can avoid memcpy'ing the parser // structure from the stack? but causes some code duplication. if (process_request(&pr, cmd, len) != 0) { proxy_lua_error(L, "failed to parse request"); return 0; } mcp_request_t *rq = mcp_new_request(L, &pr, cmd, len); if (val != NULL) { rq->pr.vlen = vlen; rq->pr.vbuf = malloc(vlen); if (rq->pr.vbuf == NULL) { // Note: without *c we can't tick the appropriate counter. // However, in practice raw malloc's are nearly never going to // fail. // TODO(v2): we can stack values into the request objects or use // the slabber memory, so this isn't necessary anyway. proxy_lua_error(L, "failed to allocate value memory for request object"); } memcpy(rq->pr.vbuf, val, vlen); // Note: Not enforcing the memory limit here is deliberate: // - if we're over the memory limit, it'll get caught very soon after // this, but we won't be causing some lua to bail mid-flight, which is // more graceful to the end user. pthread_mutex_lock(&t->proxy_limit_lock); t->proxy_buffer_memory_used += rq->pr.vlen; pthread_mutex_unlock(&t->proxy_limit_lock); } // rq is now created, parsed, and on the stack. return 1; } int mcplib_request_key(lua_State *L) { mcp_request_t *rq = luaL_checkudata(L, -1, "mcp.request"); lua_pushlstring(L, MCP_PARSER_KEY(rq->pr), rq->pr.klen); return 1; } // NOTE: I've mixed up const/non-const strings in the request. During parsing // we want it to be const, but after that's done the request is no longer // const. It might be better to just remove the const higher up the chain, but // I'd rather not. So for now these functions will be dumping the const to // modify the string. int mcplib_request_ltrimkey(lua_State *L) { mcp_request_t *rq = luaL_checkudata(L, -2, "mcp.request"); int totrim = luaL_checkinteger(L, -1); char *key = (char *) MCP_PARSER_KEY(rq->pr); if (totrim > rq->pr.klen) { proxy_lua_error(L, "ltrimkey cannot zero out key"); return 0; } else { memset(key, ' ', totrim); rq->pr.klen -= totrim; rq->pr.tokens[rq->pr.keytoken] += totrim; } return 1; } int mcplib_request_rtrimkey(lua_State *L) { mcp_request_t *rq = luaL_checkudata(L, -2, "mcp.request"); int totrim = luaL_checkinteger(L, -1); char *key = (char *) MCP_PARSER_KEY(rq->pr); if (totrim > rq->pr.klen) { proxy_lua_error(L, "rtrimkey cannot zero out key"); return 0; } else { memset(key + (rq->pr.klen - totrim), ' ', totrim); rq->pr.klen -= totrim; // don't need to change the key token. } return 1; } // Virtual table operations on the request. int mcplib_request_token(lua_State *L) { mcp_request_t *rq = luaL_checkudata(L, 1, "mcp.request"); int argc = lua_gettop(L); if (argc == 1) { lua_pushnil(L); return 1; } int token = luaL_checkinteger(L, 2); if (token < 1 || token > rq->pr.ntokens) { // maybe an error? lua_pushnil(L); return 1; } size_t vlen = 0; if (argc > 2) { // overwriting a token. size_t newlen = 0; const char *newtok = lua_tolstring(L, 3, &newlen); if (mcp_request_render(rq, token-1, newtok, newlen) != 0) { proxy_lua_error(L, "token(): request malformed after edit"); return 0; } return 0; } else { // fetching a token. const char *start = rq->pr.request + rq->pr.tokens[token-1]; vlen = _process_token_len(&rq->pr, token-1); P_DEBUG("%s: pushing token of len: %lu\n", __func__, vlen); lua_pushlstring(L, start, vlen); return 1; } return 0; } int mcplib_request_ntokens(lua_State *L) { mcp_request_t *rq = luaL_checkudata(L, 1, "mcp.request"); lua_pushinteger(L, rq->pr.ntokens); return 1; } int mcplib_request_command(lua_State *L) { mcp_request_t *rq = luaL_checkudata(L, -1, "mcp.request"); lua_pushinteger(L, rq->pr.command); return 1; } int mcplib_request_has_flag(lua_State *L) { mcp_request_t *rq = luaL_checkudata(L, 1, "mcp.request"); size_t len = 0; const char *flagstr = luaL_checklstring(L, 2, &len); if (len != 1) { proxy_lua_error(L, "has_flag(): meta flag must be a single character"); return 0; } if (flagstr[0] < 65 || flagstr[0] > 122) { proxy_lua_error(L, "has_flag(): invalid flag, must be A-Z,a-z"); return 0; } uint64_t flagbit = (uint64_t)1 << (flagstr[0] - 65); if (rq->pr.t.meta.flags & flagbit) { lua_pushboolean(L, 1); } else { lua_pushboolean(L, 0); } return 1; } // req:flag_token("F") -> (bool, nil|token) // req:flag_token("O", "Onewopauqe") -> (bool, oldtoken) int mcplib_request_flag_token(lua_State *L) { mcp_request_t *rq = luaL_checkudata(L, 1, "mcp.request"); size_t len = 0; const char *flagstr = luaL_checklstring(L, 2, &len); bool replace = false; if (len != 1) { proxy_lua_error(L, "has_flag(): meta flag must be a single character"); return 0; } if (flagstr[0] < 65 || flagstr[0] > 122) { proxy_lua_error(L, "has_flag(): invalid flag, must be A-Z,a-z"); return 0; } if (lua_isstring(L, 3)) { // overwriting a flag/token with the third argument. replace = true; } uint64_t flagbit = (uint64_t)1 << (flagstr[0] - 65); int ret = 1; if (rq->pr.t.meta.flags & flagbit) { // The flag definitely exists, but sadly we need to scan for the // actual flag to see if it has a token. lua_pushboolean(L, 1); for (int x = rq->pr.keytoken+1; x < rq->pr.ntokens; x++) { const char *s = rq->pr.request + rq->pr.tokens[x]; if (s[0] == flagstr[0]) { size_t vlen = _process_token_len(&rq->pr, x); if (vlen > 1) { // strip the flag off the token and return. lua_pushlstring(L, s+1, vlen-1); ret = 2; } // Have something to replace the flag/token with. if (replace) { size_t newlen = 0; const char *newtok = lua_tolstring(L, 3, &newlen); if (mcp_request_render(rq, x, newtok, newlen) != 0) { proxy_lua_error(L, "token(): request malformed after edit"); return 0; } } break; } } } else { lua_pushboolean(L, 0); } return ret; } int mcplib_request_gc(lua_State *L) { LIBEVENT_THREAD *t = PROXY_GET_THR(L); mcp_request_t *rq = luaL_checkudata(L, -1, "mcp.request"); // During nread c->item is the malloc'ed buffer. not yet put into // rq->buf - this gets freed because we've also set c->item_malloced if // the connection closes before finishing nread. if (rq->pr.vbuf != NULL) { pthread_mutex_lock(&t->proxy_limit_lock); t->proxy_buffer_memory_used -= rq->pr.vlen; pthread_mutex_unlock(&t->proxy_limit_lock); free(rq->pr.vbuf); } return 0; } // TODO (v2): check what lua does when it calls a function with a string argument // stored from a table/similar (ie; the prefix check code). // If it's not copying anything, we can add request-side functions to do most // forms of matching and avoid copying the key to lua space. memcached-1.6.20/stats_prefix.c0000664000175000017500000001053114302037501013303 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ /* Author: Steven Grimm */ #include "memcached.h" #include #include #include #include /* Hash table that uses the global hash function */ static PREFIX_STATS *prefix_stats[PREFIX_HASH_SIZE]; static char prefix_delimiter; static int num_prefixes = 0; static int total_prefix_size = 0; void stats_prefix_init(char delimiter) { prefix_delimiter = delimiter; memset(prefix_stats, 0, sizeof(prefix_stats)); } void stats_prefix_clear(void) { int i; for (i = 0; i < PREFIX_HASH_SIZE; i++) { PREFIX_STATS *cur, *next; for (cur = prefix_stats[i]; cur != NULL; cur = next) { next = cur->next; free(cur->prefix); free(cur); } prefix_stats[i] = NULL; } num_prefixes = 0; total_prefix_size = 0; } PREFIX_STATS *stats_prefix_find(const char *key, const size_t nkey) { PREFIX_STATS *pfs; uint32_t hashval; size_t length; bool bailout = true; assert(key != NULL); for (length = 0; length < nkey && key[length] != '\0'; length++) { if (key[length] == prefix_delimiter) { bailout = false; break; } } if (bailout) { return NULL; } hashval = hash(key, length) % PREFIX_HASH_SIZE; for (pfs = prefix_stats[hashval]; NULL != pfs; pfs = pfs->next) { if (strncmp(pfs->prefix, key, length) == 0) return pfs; } pfs = calloc(sizeof(PREFIX_STATS), 1); if (NULL == pfs) { perror("Can't allocate space for stats structure: calloc"); return NULL; } pfs->prefix = malloc(length + 1); if (NULL == pfs->prefix) { perror("Can't allocate space for copy of prefix: malloc"); free(pfs); return NULL; } strncpy(pfs->prefix, key, length); pfs->prefix[length] = '\0'; /* because strncpy() sucks */ pfs->prefix_len = length; pfs->next = prefix_stats[hashval]; prefix_stats[hashval] = pfs; num_prefixes++; total_prefix_size += length; return pfs; } void stats_prefix_record_get(const char *key, const size_t nkey, const bool is_hit) { PREFIX_STATS *pfs; STATS_LOCK(); pfs = stats_prefix_find(key, nkey); if (NULL != pfs) { pfs->num_gets++; if (is_hit) { pfs->num_hits++; } } STATS_UNLOCK(); } void stats_prefix_record_delete(const char *key, const size_t nkey) { PREFIX_STATS *pfs; STATS_LOCK(); pfs = stats_prefix_find(key, nkey); if (NULL != pfs) { pfs->num_deletes++; } STATS_UNLOCK(); } void stats_prefix_record_set(const char *key, const size_t nkey) { PREFIX_STATS *pfs; STATS_LOCK(); pfs = stats_prefix_find(key, nkey); if (NULL != pfs) { pfs->num_sets++; } STATS_UNLOCK(); } char *stats_prefix_dump(int *length) { const char *format = "PREFIX %s get %llu hit %llu set %llu del %llu\r\n"; PREFIX_STATS *pfs; char *buf; int i, pos; size_t size = 0, written = 0; #ifndef NDEBUG size_t total_written = 0; #endif /* * Figure out how big the buffer needs to be. This is the sum of the * lengths of the prefixes themselves, plus the size of one copy of * the per-prefix output with 20-digit values for all the counts, * plus space for the "END" at the end. */ STATS_LOCK(); size = strlen(format) + total_prefix_size + num_prefixes * (strlen(format) - 2 /* %s */ + 4 * (20 - 4)) /* %llu replaced by 20-digit num */ + sizeof("END\r\n"); buf = malloc(size); if (NULL == buf) { perror("Can't allocate stats response: malloc"); STATS_UNLOCK(); return NULL; } pos = 0; for (i = 0; i < PREFIX_HASH_SIZE; i++) { for (pfs = prefix_stats[i]; NULL != pfs; pfs = pfs->next) { written = snprintf(buf + pos, size-pos, format, pfs->prefix, pfs->num_gets, pfs->num_hits, pfs->num_sets, pfs->num_deletes); pos += written; #ifndef NDEBUG total_written += written; assert(total_written < size); #endif } } STATS_UNLOCK(); memcpy(buf + pos, "END\r\n", 6); *length = pos + 5; return buf; } memcached-1.6.20/logger.h0000664000175000017500000001415114427543277012102 00000000000000/* logging functions */ #ifndef LOGGER_H #define LOGGER_H #include "bipbuffer.h" /* TODO: starttime tunable */ #define LOGGER_BUF_SIZE 1024 * 64 #define LOGGER_WATCHER_BUF_SIZE 1024 * 256 #define LOGGER_ENTRY_MAX_SIZE 2048 #define GET_LOGGER() ((logger *) pthread_getspecific(logger_key)); /* Inlined from memcached.h - should go into sub header */ typedef unsigned int rel_time_t; enum log_entry_type { LOGGER_ASCII_CMD = 0, LOGGER_EVICTION, LOGGER_ITEM_GET, LOGGER_ITEM_STORE, LOGGER_CRAWLER_STATUS, LOGGER_SLAB_MOVE, LOGGER_CONNECTION_NEW, LOGGER_CONNECTION_CLOSE, LOGGER_DELETIONS, #ifdef EXTSTORE LOGGER_EXTSTORE_WRITE, LOGGER_COMPACT_START, LOGGER_COMPACT_ABORT, LOGGER_COMPACT_READ_START, LOGGER_COMPACT_READ_END, LOGGER_COMPACT_END, LOGGER_COMPACT_FRAGINFO, #endif #ifdef PROXY LOGGER_PROXY_CONFIG, LOGGER_PROXY_RAW, LOGGER_PROXY_ERROR, LOGGER_PROXY_USER, LOGGER_PROXY_REQ, LOGGER_PROXY_BE_ERROR, #endif }; enum logger_ret_type { LOGGER_RET_OK = 0, LOGGER_RET_NOSPACE, LOGGER_RET_ERR }; enum logger_parse_entry_ret { LOGGER_PARSE_ENTRY_OK = 0, LOGGER_PARSE_ENTRY_FULLBUF, LOGGER_PARSE_ENTRY_FAILED }; typedef struct _logentry logentry; typedef struct _entry_details entry_details; typedef void (*entry_log_cb)(logentry *e, const entry_details *d, const void *entry, va_list ap); typedef int (*entry_parse_cb)(logentry *e, char *scratch); struct _entry_details { int reqlen; uint16_t eflags; entry_log_cb log_cb; entry_parse_cb parse_cb; char *format; }; /* log entry intermediary structures */ struct logentry_eviction { long long int exptime; int nbytes; uint32_t latime; uint16_t it_flags; uint8_t nkey; uint8_t clsid; char key[]; }; #ifdef EXTSTORE struct logentry_ext_write { long long int exptime; uint32_t latime; uint16_t it_flags; uint8_t nkey; uint8_t clsid; uint8_t bucket; char key[]; }; #endif struct logentry_item_get { uint8_t was_found; uint8_t nkey; uint8_t clsid; int nbytes; int sfd; char key[]; }; struct logentry_item_store { int status; int cmd; rel_time_t ttl; uint8_t nkey; uint8_t clsid; int nbytes; int sfd; char key[]; }; struct logentry_deletion { int nbytes; int cmd; uint8_t nkey; uint8_t clsid; char key[]; }; struct logentry_conn_event { int transport; int reason; int sfd; struct sockaddr_in6 addr; }; #ifdef PROXY struct logentry_proxy_req { unsigned short type; unsigned short code; int status; uint32_t reqlen; size_t dlen; size_t be_namelen; size_t be_portlen; long elapsed; char data[]; }; struct logentry_proxy_errbe { size_t errlen; size_t be_namelen; size_t be_portlen; size_t be_rbuflen; int be_depth; char data[]; }; #endif /* end intermediary structures */ /* WARNING: cuddled items aren't compatible with warm restart. more code * necessary to ensure log streams are all flushed/processed before stopping */ struct _logentry { enum log_entry_type event; uint8_t pad; uint16_t eflags; uint64_t gid; struct timeval tv; /* not monotonic! */ int size; union { char end; } data[]; }; #define LOG_SYSEVENTS (1<<1) /* threads start/stop/working */ #define LOG_FETCHERS (1<<2) /* get/gets/etc */ #define LOG_MUTATIONS (1<<3) /* set/append/incr/etc */ #define LOG_SYSERRORS (1<<4) /* malloc/etc errors */ #define LOG_CONNEVENTS (1<<5) /* new client, closed, etc */ #define LOG_EVICTIONS (1<<6) /* details of evicted items */ #define LOG_STRICT (1<<7) /* block worker instead of drop */ #define LOG_RAWCMDS (1<<9) /* raw ascii commands */ #define LOG_PROXYREQS (1<<10) /* command logs from proxy */ #define LOG_PROXYEVENTS (1<<11) /* error log stream from proxy */ #define LOG_PROXYUSER (1<<12) /* user generated logs from proxy */ #define LOG_DELETIONS (1<<13) /* see whats deleted */ typedef struct _logger { struct _logger *prev; struct _logger *next; pthread_mutex_t mutex; /* guard for this + *buf */ uint64_t written; /* entries written to the buffer */ uint64_t dropped; /* entries dropped */ uint64_t blocked; /* times blocked instead of dropped */ uint16_t fetcher_ratio; /* log one out of every N fetches */ uint16_t mutation_ratio; /* log one out of every N mutations */ uint16_t eflags; /* flags this logger should log */ bipbuf_t *buf; const entry_details *entry_map; } logger; enum logger_watcher_type { LOGGER_WATCHER_STDERR = 0, LOGGER_WATCHER_CLIENT = 1 }; typedef struct { void *c; /* original connection structure. still with source thread attached */ int sfd; /* client fd */ int id; /* id number for watcher list */ uint64_t skipped; /* lines skipped since last successful print */ uint64_t min_gid; /* don't show log entries older than this GID */ bool failed_flush; /* recently failed to write out (EAGAIN), wait before retry */ enum logger_watcher_type t; /* stderr, client, syslog, etc */ uint16_t eflags; /* flags we are interested in */ bipbuf_t *buf; /* per-watcher output buffer */ } logger_watcher; struct logger_stats { uint64_t worker_dropped; uint64_t worker_written; uint64_t watcher_skipped; uint64_t watcher_sent; uint64_t watcher_count; }; extern pthread_key_t logger_key; /* public functions */ void logger_init(void); void logger_stop(void); logger *logger_create(void); #define LOGGER_LOG(l, flag, type, ...) \ do { \ logger *myl = l; \ if (l == NULL) \ myl = GET_LOGGER(); \ if (myl->eflags & flag) \ logger_log(myl, type, __VA_ARGS__); \ } while (0) enum logger_ret_type logger_log(logger *l, const enum log_entry_type event, const void *entry, ...); enum logger_add_watcher_ret { LOGGER_ADD_WATCHER_TOO_MANY = 0, LOGGER_ADD_WATCHER_OK, LOGGER_ADD_WATCHER_FAILED }; enum logger_add_watcher_ret logger_add_watcher(void *c, const int sfd, uint16_t f); /* functions used by restart system */ uint64_t logger_get_gid(void); void logger_set_gid(uint64_t gid); #endif memcached-1.6.20/missing0000755000175000017500000001533614215102164012032 00000000000000#! /bin/sh # Common wrapper for a few potentially missing GNU programs. scriptversion=2018-03-07.03; # UTC # Copyright (C) 1996-2021 Free Software Foundation, Inc. # Originally written by Fran,cois Pinard , 1996. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see . # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. if test $# -eq 0; then echo 1>&2 "Try '$0 --help' for more information" exit 1 fi case $1 in --is-lightweight) # Used by our autoconf macros to check whether the available missing # script is modern enough. exit 0 ;; --run) # Back-compat with the calling convention used by older automake. shift ;; -h|--h|--he|--hel|--help) echo "\ $0 [OPTION]... PROGRAM [ARGUMENT]... Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due to PROGRAM being missing or too old. Options: -h, --help display this help and exit -v, --version output version information and exit Supported PROGRAM values: aclocal autoconf autoheader autom4te automake makeinfo bison yacc flex lex help2man Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and 'g' are ignored when checking the name. Send bug reports to ." exit $? ;; -v|--v|--ve|--ver|--vers|--versi|--versio|--version) echo "missing $scriptversion (GNU Automake)" exit $? ;; -*) echo 1>&2 "$0: unknown '$1' option" echo 1>&2 "Try '$0 --help' for more information" exit 1 ;; esac # Run the given program, remember its exit status. "$@"; st=$? # If it succeeded, we are done. test $st -eq 0 && exit 0 # Also exit now if we it failed (or wasn't found), and '--version' was # passed; such an option is passed most likely to detect whether the # program is present and works. case $2 in --version|--help) exit $st;; esac # Exit code 63 means version mismatch. This often happens when the user # tries to use an ancient version of a tool on a file that requires a # minimum version. if test $st -eq 63; then msg="probably too old" elif test $st -eq 127; then # Program was missing. msg="missing on your system" else # Program was found and executed, but failed. Give up. exit $st fi perl_URL=https://www.perl.org/ flex_URL=https://github.com/westes/flex gnu_software_URL=https://www.gnu.org/software program_details () { case $1 in aclocal|automake) echo "The '$1' program is part of the GNU Automake package:" echo "<$gnu_software_URL/automake>" echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:" echo "<$gnu_software_URL/autoconf>" echo "<$gnu_software_URL/m4/>" echo "<$perl_URL>" ;; autoconf|autom4te|autoheader) echo "The '$1' program is part of the GNU Autoconf package:" echo "<$gnu_software_URL/autoconf/>" echo "It also requires GNU m4 and Perl in order to run:" echo "<$gnu_software_URL/m4/>" echo "<$perl_URL>" ;; esac } give_advice () { # Normalize program name to check for. normalized_program=`echo "$1" | sed ' s/^gnu-//; t s/^gnu//; t s/^g//; t'` printf '%s\n' "'$1' is $msg." configure_deps="'configure.ac' or m4 files included by 'configure.ac'" case $normalized_program in autoconf*) echo "You should only need it if you modified 'configure.ac'," echo "or m4 files included by it." program_details 'autoconf' ;; autoheader*) echo "You should only need it if you modified 'acconfig.h' or" echo "$configure_deps." program_details 'autoheader' ;; automake*) echo "You should only need it if you modified 'Makefile.am' or" echo "$configure_deps." program_details 'automake' ;; aclocal*) echo "You should only need it if you modified 'acinclude.m4' or" echo "$configure_deps." program_details 'aclocal' ;; autom4te*) echo "You might have modified some maintainer files that require" echo "the 'autom4te' program to be rebuilt." program_details 'autom4te' ;; bison*|yacc*) echo "You should only need it if you modified a '.y' file." echo "You may want to install the GNU Bison package:" echo "<$gnu_software_URL/bison/>" ;; lex*|flex*) echo "You should only need it if you modified a '.l' file." echo "You may want to install the Fast Lexical Analyzer package:" echo "<$flex_URL>" ;; help2man*) echo "You should only need it if you modified a dependency" \ "of a man page." echo "You may want to install the GNU Help2man package:" echo "<$gnu_software_URL/help2man/>" ;; makeinfo*) echo "You should only need it if you modified a '.texi' file, or" echo "any other file indirectly affecting the aspect of the manual." echo "You might want to install the Texinfo package:" echo "<$gnu_software_URL/texinfo/>" echo "The spurious makeinfo call might also be the consequence of" echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might" echo "want to install GNU make:" echo "<$gnu_software_URL/make/>" ;; *) echo "You might have modified some files without having the proper" echo "tools for further handling them. Check the 'README' file, it" echo "often tells you about the needed prerequisites for installing" echo "this package. You may also peek at any GNU archive site, in" echo "case some other package contains this missing '$1' program." ;; esac } give_advice "$1" | sed -e '1s/^/WARNING: /' \ -e '2,$s/^/ /' >&2 # Propagate the correct exit status (expected to be 127 for a program # not found, 63 for a program that failed due to version mismatch). exit $st # Local variables: # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC0" # time-stamp-end: "; # UTC" # End: memcached-1.6.20/config.guess0000755000175000017500000014051214175772605012770 00000000000000#! /bin/sh # Attempt to guess a canonical system name. # Copyright 1992-2022 Free Software Foundation, Inc. # shellcheck disable=SC2006,SC2268 # see below for rationale timestamp='2022-01-09' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that # program. This Exception is an additional permission under section 7 # of the GNU General Public License, version 3 ("GPLv3"). # # Originally written by Per Bothner; maintained since 2000 by Ben Elliston. # # You can get the latest version of this script from: # https://git.savannah.gnu.org/cgit/config.git/plain/config.guess # # Please send patches to . # The "shellcheck disable" line above the timestamp inhibits complaints # about features and limitations of the classic Bourne shell that were # superseded or lifted in POSIX. However, this script identifies a wide # variety of pre-POSIX systems that do not have POSIX shells at all, and # even some reasonably current systems (Solaris 10 as case-in-point) still # have a pre-POSIX /bin/sh. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] Output the configuration name of the system \`$me' is run on. Options: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. Copyright 1992-2022 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; * ) break ;; esac done if test $# != 0; then echo "$me: too many arguments$help" >&2 exit 1 fi # Just in case it came from the environment. GUESS= # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a # headache to deal with in a portable fashion. # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still # use `HOST_CC' if defined, but it is deprecated. # Portable tmp directory creation inspired by the Autoconf team. tmp= # shellcheck disable=SC2172 trap 'test -z "$tmp" || rm -fr "$tmp"' 0 1 2 13 15 set_cc_for_build() { # prevent multiple calls if $tmp is already set test "$tmp" && return 0 : "${TMPDIR=/tmp}" # shellcheck disable=SC2039,SC3028 { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir "$tmp" 2>/dev/null) ; } || { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir "$tmp" 2>/dev/null) && echo "Warning: creating insecure temp directory" >&2 ; } || { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } dummy=$tmp/dummy case ${CC_FOR_BUILD-},${HOST_CC-},${CC-} in ,,) echo "int x;" > "$dummy.c" for driver in cc gcc c89 c99 ; do if ($driver -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then CC_FOR_BUILD=$driver break fi done if test x"$CC_FOR_BUILD" = x ; then CC_FOR_BUILD=no_compiler_found fi ;; ,,*) CC_FOR_BUILD=$CC ;; ,*,*) CC_FOR_BUILD=$HOST_CC ;; esac } # This is needed to find uname on a Pyramid OSx when run in the BSD universe. # (ghazi@noc.rutgers.edu 1994-08-24) if test -f /.attbin/uname ; then PATH=$PATH:/.attbin ; export PATH fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown case $UNAME_SYSTEM in Linux|GNU|GNU/*) LIBC=unknown set_cc_for_build cat <<-EOF > "$dummy.c" #include #if defined(__UCLIBC__) LIBC=uclibc #elif defined(__dietlibc__) LIBC=dietlibc #elif defined(__GLIBC__) LIBC=gnu #else #include /* First heuristic to detect musl libc. */ #ifdef __DEFINED_va_list LIBC=musl #endif #endif EOF cc_set_libc=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'` eval "$cc_set_libc" # Second heuristic to detect musl libc. if [ "$LIBC" = unknown ] && command -v ldd >/dev/null && ldd --version 2>&1 | grep -q ^musl; then LIBC=musl fi # If the system lacks a compiler, then just pick glibc. # We could probably try harder. if [ "$LIBC" = unknown ]; then LIBC=gnu fi ;; esac # Note: order is significant - the case branches are not exclusive. case $UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION in *:NetBSD:*:*) # NetBSD (nbsd) targets should (where applicable) match one or # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently # switched to ELF, *-*-netbsd* would select the old # object file format. This provides both forward # compatibility and a consistent mechanism for selecting the # object file format. # # Note: NetBSD doesn't particularly care about the vendor # portion of the name. We always set it to "unknown". UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \ /sbin/sysctl -n hw.machine_arch 2>/dev/null || \ /usr/sbin/sysctl -n hw.machine_arch 2>/dev/null || \ echo unknown)` case $UNAME_MACHINE_ARCH in aarch64eb) machine=aarch64_be-unknown ;; armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; sh3eb) machine=sh-unknown ;; sh5el) machine=sh5le-unknown ;; earmv*) arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'` endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'` machine=${arch}${endian}-unknown ;; *) machine=$UNAME_MACHINE_ARCH-unknown ;; esac # The Operating System including object format, if it has switched # to ELF recently (or will in the future) and ABI. case $UNAME_MACHINE_ARCH in earm*) os=netbsdelf ;; arm*|i386|m68k|ns32k|sh3*|sparc|vax) set_cc_for_build if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ELF__ then # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). # Return netbsd for either. FIX? os=netbsd else os=netbsdelf fi ;; *) os=netbsd ;; esac # Determine ABI tags. case $UNAME_MACHINE_ARCH in earm*) expr='s/^earmv[0-9]/-eabi/;s/eb$//' abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"` ;; esac # The OS release # Debian GNU/NetBSD machines have a different userland, and # thus, need a distinct triplet. However, they do not need # kernel version information, so it can be replaced with a # suitable tag, in the style of linux-gnu. case $UNAME_VERSION in Debian*) release='-gnu' ;; *) release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2` ;; esac # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. GUESS=$machine-${os}${release}${abi-} ;; *:Bitrig:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` GUESS=$UNAME_MACHINE_ARCH-unknown-bitrig$UNAME_RELEASE ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` GUESS=$UNAME_MACHINE_ARCH-unknown-openbsd$UNAME_RELEASE ;; *:SecBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/SecBSD.//'` GUESS=$UNAME_MACHINE_ARCH-unknown-secbsd$UNAME_RELEASE ;; *:LibertyBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'` GUESS=$UNAME_MACHINE_ARCH-unknown-libertybsd$UNAME_RELEASE ;; *:MidnightBSD:*:*) GUESS=$UNAME_MACHINE-unknown-midnightbsd$UNAME_RELEASE ;; *:ekkoBSD:*:*) GUESS=$UNAME_MACHINE-unknown-ekkobsd$UNAME_RELEASE ;; *:SolidBSD:*:*) GUESS=$UNAME_MACHINE-unknown-solidbsd$UNAME_RELEASE ;; *:OS108:*:*) GUESS=$UNAME_MACHINE-unknown-os108_$UNAME_RELEASE ;; macppc:MirBSD:*:*) GUESS=powerpc-unknown-mirbsd$UNAME_RELEASE ;; *:MirBSD:*:*) GUESS=$UNAME_MACHINE-unknown-mirbsd$UNAME_RELEASE ;; *:Sortix:*:*) GUESS=$UNAME_MACHINE-unknown-sortix ;; *:Twizzler:*:*) GUESS=$UNAME_MACHINE-unknown-twizzler ;; *:Redox:*:*) GUESS=$UNAME_MACHINE-unknown-redox ;; mips:OSF1:*.*) GUESS=mips-dec-osf1 ;; alpha:OSF1:*:*) # Reset EXIT trap before exiting to avoid spurious non-zero exit code. trap '' 0 case $UNAME_RELEASE in *4.0) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ;; *5.*) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ;; esac # According to Compaq, /usr/sbin/psrinfo has been available on # OSF/1 and Tru64 systems produced since 1995. I hope that # covers most systems running today. This code pipes the CPU # types through head -n 1, so we only detect the type of CPU 0. ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` case $ALPHA_CPU_TYPE in "EV4 (21064)") UNAME_MACHINE=alpha ;; "EV4.5 (21064)") UNAME_MACHINE=alpha ;; "LCA4 (21066/21068)") UNAME_MACHINE=alpha ;; "EV5 (21164)") UNAME_MACHINE=alphaev5 ;; "EV5.6 (21164A)") UNAME_MACHINE=alphaev56 ;; "EV5.6 (21164PC)") UNAME_MACHINE=alphapca56 ;; "EV5.7 (21164PC)") UNAME_MACHINE=alphapca57 ;; "EV6 (21264)") UNAME_MACHINE=alphaev6 ;; "EV6.7 (21264A)") UNAME_MACHINE=alphaev67 ;; "EV6.8CB (21264C)") UNAME_MACHINE=alphaev68 ;; "EV6.8AL (21264B)") UNAME_MACHINE=alphaev68 ;; "EV6.8CX (21264D)") UNAME_MACHINE=alphaev68 ;; "EV6.9A (21264/EV69A)") UNAME_MACHINE=alphaev69 ;; "EV7 (21364)") UNAME_MACHINE=alphaev7 ;; "EV7.9 (21364A)") UNAME_MACHINE=alphaev79 ;; esac # A Pn.n version is a patched version. # A Vn.n version is a released version. # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. OSF_REL=`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` GUESS=$UNAME_MACHINE-dec-osf$OSF_REL ;; Amiga*:UNIX_System_V:4.0:*) GUESS=m68k-unknown-sysv4 ;; *:[Aa]miga[Oo][Ss]:*:*) GUESS=$UNAME_MACHINE-unknown-amigaos ;; *:[Mm]orph[Oo][Ss]:*:*) GUESS=$UNAME_MACHINE-unknown-morphos ;; *:OS/390:*:*) GUESS=i370-ibm-openedition ;; *:z/VM:*:*) GUESS=s390-ibm-zvmoe ;; *:OS400:*:*) GUESS=powerpc-ibm-os400 ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) GUESS=arm-acorn-riscix$UNAME_RELEASE ;; arm*:riscos:*:*|arm*:RISCOS:*:*) GUESS=arm-unknown-riscos ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) GUESS=hppa1.1-hitachi-hiuxmpp ;; Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. case `(/bin/universe) 2>/dev/null` in att) GUESS=pyramid-pyramid-sysv3 ;; *) GUESS=pyramid-pyramid-bsd ;; esac ;; NILE*:*:*:dcosx) GUESS=pyramid-pyramid-svr4 ;; DRS?6000:unix:4.0:6*) GUESS=sparc-icl-nx6 ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in sparc) GUESS=sparc-icl-nx7 ;; esac ;; s390x:SunOS:*:*) SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=$UNAME_MACHINE-ibm-solaris2$SUN_REL ;; sun4H:SunOS:5.*:*) SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=sparc-hal-solaris2$SUN_REL ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=sparc-sun-solaris2$SUN_REL ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) GUESS=i386-pc-auroraux$UNAME_RELEASE ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) set_cc_for_build SUN_ARCH=i386 # If there is a compiler, see if it is configured for 64-bit objects. # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. # This test works for both compilers. if test "$CC_FOR_BUILD" != no_compiler_found; then if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -m64 -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then SUN_ARCH=x86_64 fi fi SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=$SUN_ARCH-pc-solaris2$SUN_REL ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=sparc-sun-solaris3$SUN_REL ;; sun4*:SunOS:*:*) case `/usr/bin/arch -k` in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/'` GUESS=sparc-sun-sunos$SUN_REL ;; sun3*:SunOS:*:*) GUESS=m68k-sun-sunos$UNAME_RELEASE ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3 case `/bin/arch` in sun3) GUESS=m68k-sun-sunos$UNAME_RELEASE ;; sun4) GUESS=sparc-sun-sunos$UNAME_RELEASE ;; esac ;; aushp:SunOS:*:*) GUESS=sparc-auspex-sunos$UNAME_RELEASE ;; # The situation for MiNT is a little confusing. The machine name # can be virtually everything (everything which is not # "atarist" or "atariste" at least should have a processor # > m68000). The system name ranges from "MiNT" over "FreeMiNT" # to the lowercase version "mint" (or "freemint"). Finally # the system name "TOS" denotes a system which is actually not # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) GUESS=m68k-atari-mint$UNAME_RELEASE ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) GUESS=m68k-atari-mint$UNAME_RELEASE ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) GUESS=m68k-atari-mint$UNAME_RELEASE ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) GUESS=m68k-milan-mint$UNAME_RELEASE ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) GUESS=m68k-hades-mint$UNAME_RELEASE ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) GUESS=m68k-unknown-mint$UNAME_RELEASE ;; m68k:machten:*:*) GUESS=m68k-apple-machten$UNAME_RELEASE ;; powerpc:machten:*:*) GUESS=powerpc-apple-machten$UNAME_RELEASE ;; RISC*:Mach:*:*) GUESS=mips-dec-mach_bsd4.3 ;; RISC*:ULTRIX:*:*) GUESS=mips-dec-ultrix$UNAME_RELEASE ;; VAX*:ULTRIX*:*:*) GUESS=vax-dec-ultrix$UNAME_RELEASE ;; 2020:CLIX:*:* | 2430:CLIX:*:*) GUESS=clipper-intergraph-clix$UNAME_RELEASE ;; mips:*:*:UMIPS | mips:*:*:RISCos) set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #ifdef __cplusplus #include /* for printf() prototype */ int main (int argc, char *argv[]) { #else int main (argc, argv) int argc; char *argv[]; { #endif #if defined (host_mips) && defined (MIPSEB) #if defined (SYSTYPE_SYSV) printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_SVR4) printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0); #endif #endif exit (-1); } EOF $CC_FOR_BUILD -o "$dummy" "$dummy.c" && dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`"$dummy" "$dummyarg"` && { echo "$SYSTEM_NAME"; exit; } GUESS=mips-mips-riscos$UNAME_RELEASE ;; Motorola:PowerMAX_OS:*:*) GUESS=powerpc-motorola-powermax ;; Motorola:*:4.3:PL8-*) GUESS=powerpc-harris-powermax ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) GUESS=powerpc-harris-powermax ;; Night_Hawk:Power_UNIX:*:*) GUESS=powerpc-harris-powerunix ;; m88k:CX/UX:7*:*) GUESS=m88k-harris-cxux7 ;; m88k:*:4*:R4*) GUESS=m88k-motorola-sysv4 ;; m88k:*:3*:R3*) GUESS=m88k-motorola-sysv3 ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` if test "$UNAME_PROCESSOR" = mc88100 || test "$UNAME_PROCESSOR" = mc88110 then if test "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx || \ test "$TARGET_BINARY_INTERFACE"x = x then GUESS=m88k-dg-dgux$UNAME_RELEASE else GUESS=m88k-dg-dguxbcs$UNAME_RELEASE fi else GUESS=i586-dg-dgux$UNAME_RELEASE fi ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) GUESS=m88k-dolphin-sysv3 ;; M88*:*:R3*:*) # Delta 88k system running SVR3 GUESS=m88k-motorola-sysv3 ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) GUESS=m88k-tektronix-sysv3 ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) GUESS=m68k-tektronix-bsd ;; *:IRIX*:*:*) IRIX_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/g'` GUESS=mips-sgi-irix$IRIX_REL ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. GUESS=romp-ibm-aix # uname -m gives an 8 hex-code CPU id ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) GUESS=i386-ibm-aix ;; ia64:AIX:*:*) if test -x /usr/bin/oslevel ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=$UNAME_VERSION.$UNAME_RELEASE fi GUESS=$UNAME_MACHINE-ibm-aix$IBM_REV ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #include main() { if (!__power_pc()) exit(1); puts("powerpc-ibm-aix3.2.5"); exit(0); } EOF if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` then GUESS=$SYSTEM_NAME else GUESS=rs6000-ibm-aix3.2.5 fi elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then GUESS=rs6000-ibm-aix3.2.4 else GUESS=rs6000-ibm-aix3.2 fi ;; *:AIX:*:[4567]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then IBM_ARCH=rs6000 else IBM_ARCH=powerpc fi if test -x /usr/bin/lslpp ; then IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | \ awk -F: '{ print $3 }' | sed s/[0-9]*$/0/` else IBM_REV=$UNAME_VERSION.$UNAME_RELEASE fi GUESS=$IBM_ARCH-ibm-aix$IBM_REV ;; *:AIX:*:*) GUESS=rs6000-ibm-aix ;; ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*) GUESS=romp-ibm-bsd4.4 ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and GUESS=romp-ibm-bsd$UNAME_RELEASE # 4.3 with uname added to ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) GUESS=rs6000-bull-bosx ;; DPX/2?00:B.O.S.:*:*) GUESS=m68k-bull-sysv3 ;; 9000/[34]??:4.3bsd:1.*:*) GUESS=m68k-hp-bsd ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) GUESS=m68k-hp-bsd4.4 ;; 9000/[34678]??:HP-UX:*:*) HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'` case $UNAME_MACHINE in 9000/31?) HP_ARCH=m68000 ;; 9000/[34]??) HP_ARCH=m68k ;; 9000/[678][0-9][0-9]) if test -x /usr/bin/getconf; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` case $sc_cpu_version in 523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0 528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1 532) # CPU_PA_RISC2_0 case $sc_kernel_bits in 32) HP_ARCH=hppa2.0n ;; 64) HP_ARCH=hppa2.0w ;; '') HP_ARCH=hppa2.0 ;; # HP-UX 10.20 esac ;; esac fi if test "$HP_ARCH" = ""; then set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #define _HPUX_SOURCE #include #include int main () { #if defined(_SC_KERNEL_BITS) long bits = sysconf(_SC_KERNEL_BITS); #endif long cpu = sysconf (_SC_CPU_VERSION); switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0"); break; case CPU_PA_RISC1_1: puts ("hppa1.1"); break; case CPU_PA_RISC2_0: #if defined(_SC_KERNEL_BITS) switch (bits) { case 64: puts ("hppa2.0w"); break; case 32: puts ("hppa2.0n"); break; default: puts ("hppa2.0"); break; } break; #else /* !defined(_SC_KERNEL_BITS) */ puts ("hppa2.0"); break; #endif default: puts ("hppa1.0"); break; } exit (0); } EOF (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"` test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac if test "$HP_ARCH" = hppa2.0w then set_cc_for_build # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # # $ CC_FOR_BUILD=cc ./config.guess # => hppa2.0w-hp-hpux11.23 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess # => hppa64-hp-hpux11.23 if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | grep -q __LP64__ then HP_ARCH=hppa2.0w else HP_ARCH=hppa64 fi fi GUESS=$HP_ARCH-hp-hpux$HPUX_REV ;; ia64:HP-UX:*:*) HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'` GUESS=ia64-hp-hpux$HPUX_REV ;; 3050*:HI-UX:*:*) set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #include int main () { long cpu = sysconf (_SC_CPU_VERSION); /* The order matters, because CPU_IS_HP_MC68K erroneously returns true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct results, however. */ if (CPU_IS_PA_RISC (cpu)) { switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; default: puts ("hppa-hitachi-hiuxwe2"); break; } } else if (CPU_IS_HP_MC68K (cpu)) puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); } EOF $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` && { echo "$SYSTEM_NAME"; exit; } GUESS=unknown-hitachi-hiuxwe2 ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*) GUESS=hppa1.1-hp-bsd ;; 9000/8??:4.3bsd:*:*) GUESS=hppa1.0-hp-bsd ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) GUESS=hppa1.0-hp-mpeix ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*) GUESS=hppa1.1-hp-osf ;; hp8??:OSF1:*:*) GUESS=hppa1.0-hp-osf ;; i*86:OSF1:*:*) if test -x /usr/sbin/sysversion ; then GUESS=$UNAME_MACHINE-unknown-osf1mk else GUESS=$UNAME_MACHINE-unknown-osf1 fi ;; parisc*:Lites*:*:*) GUESS=hppa1.1-hp-lites ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) GUESS=c1-convex-bsd ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) GUESS=c34-convex-bsd ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) GUESS=c38-convex-bsd ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) GUESS=c4-convex-bsd ;; CRAY*Y-MP:*:*:*) CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` GUESS=ymp-cray-unicos$CRAY_REL ;; CRAY*[A-Z]90:*:*:*) echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ -e 's/\.[^.]*$/.X/' exit ;; CRAY*TS:*:*:*) CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` GUESS=t90-cray-unicos$CRAY_REL ;; CRAY*T3E:*:*:*) CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` GUESS=alphaev5-cray-unicosmk$CRAY_REL ;; CRAY*SV1:*:*:*) CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` GUESS=sv1-cray-unicos$CRAY_REL ;; *:UNICOS/mp:*:*) CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` GUESS=craynv-cray-unicosmp$CRAY_REL ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'` GUESS=${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL} ;; 5000:UNIX_System_V:4.*:*) FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'` GUESS=sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL} ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) GUESS=$UNAME_MACHINE-pc-bsdi$UNAME_RELEASE ;; sparc*:BSD/OS:*:*) GUESS=sparc-unknown-bsdi$UNAME_RELEASE ;; *:BSD/OS:*:*) GUESS=$UNAME_MACHINE-unknown-bsdi$UNAME_RELEASE ;; arm:FreeBSD:*:*) UNAME_PROCESSOR=`uname -p` set_cc_for_build if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_PCS_VFP then FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabi else FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabihf fi ;; *:FreeBSD:*:*) UNAME_PROCESSOR=`/usr/bin/uname -p` case $UNAME_PROCESSOR in amd64) UNAME_PROCESSOR=x86_64 ;; i386) UNAME_PROCESSOR=i586 ;; esac FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL ;; i*:CYGWIN*:*) GUESS=$UNAME_MACHINE-pc-cygwin ;; *:MINGW64*:*) GUESS=$UNAME_MACHINE-pc-mingw64 ;; *:MINGW*:*) GUESS=$UNAME_MACHINE-pc-mingw32 ;; *:MSYS*:*) GUESS=$UNAME_MACHINE-pc-msys ;; i*:PW*:*) GUESS=$UNAME_MACHINE-pc-pw32 ;; *:SerenityOS:*:*) GUESS=$UNAME_MACHINE-pc-serenity ;; *:Interix*:*) case $UNAME_MACHINE in x86) GUESS=i586-pc-interix$UNAME_RELEASE ;; authenticamd | genuineintel | EM64T) GUESS=x86_64-unknown-interix$UNAME_RELEASE ;; IA64) GUESS=ia64-unknown-interix$UNAME_RELEASE ;; esac ;; i*:UWIN*:*) GUESS=$UNAME_MACHINE-pc-uwin ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) GUESS=x86_64-pc-cygwin ;; prep*:SunOS:5.*:*) SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=powerpcle-unknown-solaris2$SUN_REL ;; *:GNU:*:*) # the GNU system GNU_ARCH=`echo "$UNAME_MACHINE" | sed -e 's,[-/].*$,,'` GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's,/.*$,,'` GUESS=$GNU_ARCH-unknown-$LIBC$GNU_REL ;; *:GNU/*:*:*) # other systems with GNU libc and userland GNU_SYS=`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"` GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` GUESS=$UNAME_MACHINE-unknown-$GNU_SYS$GNU_REL-$LIBC ;; *:Minix:*:*) GUESS=$UNAME_MACHINE-unknown-minix ;; aarch64:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; aarch64_be:Linux:*:*) UNAME_MACHINE=aarch64_be GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; alpha:Linux:*:*) case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' /proc/cpuinfo 2>/dev/null` in EV5) UNAME_MACHINE=alphaev5 ;; EV56) UNAME_MACHINE=alphaev56 ;; PCA56) UNAME_MACHINE=alphapca56 ;; PCA57) UNAME_MACHINE=alphapca56 ;; EV6) UNAME_MACHINE=alphaev6 ;; EV67) UNAME_MACHINE=alphaev67 ;; EV68*) UNAME_MACHINE=alphaev68 ;; esac objdump --private-headers /bin/sh | grep -q ld.so.1 if test "$?" = 0 ; then LIBC=gnulibc1 ; fi GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; arc:Linux:*:* | arceb:Linux:*:* | arc32:Linux:*:* | arc64:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; arm*:Linux:*:*) set_cc_for_build if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then GUESS=$UNAME_MACHINE-unknown-linux-$LIBC else if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_PCS_VFP then GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabi else GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabihf fi fi ;; avr32*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; cris:Linux:*:*) GUESS=$UNAME_MACHINE-axis-linux-$LIBC ;; crisv32:Linux:*:*) GUESS=$UNAME_MACHINE-axis-linux-$LIBC ;; e2k:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; frv:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; hexagon:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; i*86:Linux:*:*) GUESS=$UNAME_MACHINE-pc-linux-$LIBC ;; ia64:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; k1om:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; loongarch32:Linux:*:* | loongarch64:Linux:*:* | loongarchx32:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; m32r*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; m68*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; mips:Linux:*:* | mips64:Linux:*:*) set_cc_for_build IS_GLIBC=0 test x"${LIBC}" = xgnu && IS_GLIBC=1 sed 's/^ //' << EOF > "$dummy.c" #undef CPU #undef mips #undef mipsel #undef mips64 #undef mips64el #if ${IS_GLIBC} && defined(_ABI64) LIBCABI=gnuabi64 #else #if ${IS_GLIBC} && defined(_ABIN32) LIBCABI=gnuabin32 #else LIBCABI=${LIBC} #endif #endif #if ${IS_GLIBC} && defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6 CPU=mipsisa64r6 #else #if ${IS_GLIBC} && !defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6 CPU=mipsisa32r6 #else #if defined(__mips64) CPU=mips64 #else CPU=mips #endif #endif #endif #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) MIPS_ENDIAN=el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) MIPS_ENDIAN= #else MIPS_ENDIAN= #endif #endif EOF cc_set_vars=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU\|^MIPS_ENDIAN\|^LIBCABI'` eval "$cc_set_vars" test "x$CPU" != x && { echo "$CPU${MIPS_ENDIAN}-unknown-linux-$LIBCABI"; exit; } ;; mips64el:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; openrisc*:Linux:*:*) GUESS=or1k-unknown-linux-$LIBC ;; or32:Linux:*:* | or1k*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; padre:Linux:*:*) GUESS=sparc-unknown-linux-$LIBC ;; parisc64:Linux:*:* | hppa64:Linux:*:*) GUESS=hppa64-unknown-linux-$LIBC ;; parisc:Linux:*:* | hppa:Linux:*:*) # Look for CPU level case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in PA7*) GUESS=hppa1.1-unknown-linux-$LIBC ;; PA8*) GUESS=hppa2.0-unknown-linux-$LIBC ;; *) GUESS=hppa-unknown-linux-$LIBC ;; esac ;; ppc64:Linux:*:*) GUESS=powerpc64-unknown-linux-$LIBC ;; ppc:Linux:*:*) GUESS=powerpc-unknown-linux-$LIBC ;; ppc64le:Linux:*:*) GUESS=powerpc64le-unknown-linux-$LIBC ;; ppcle:Linux:*:*) GUESS=powerpcle-unknown-linux-$LIBC ;; riscv32:Linux:*:* | riscv32be:Linux:*:* | riscv64:Linux:*:* | riscv64be:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; s390:Linux:*:* | s390x:Linux:*:*) GUESS=$UNAME_MACHINE-ibm-linux-$LIBC ;; sh64*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; sh*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; sparc:Linux:*:* | sparc64:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; tile*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; vax:Linux:*:*) GUESS=$UNAME_MACHINE-dec-linux-$LIBC ;; x86_64:Linux:*:*) set_cc_for_build LIBCABI=$LIBC if test "$CC_FOR_BUILD" != no_compiler_found; then if (echo '#ifdef __ILP32__'; echo IS_X32; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_X32 >/dev/null then LIBCABI=${LIBC}x32 fi fi GUESS=$UNAME_MACHINE-pc-linux-$LIBCABI ;; xtensa*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. # earlier versions are messed up and put the nodename in both # sysname and nodename. GUESS=i386-sequent-sysv4 ;; i*86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. GUESS=$UNAME_MACHINE-pc-sysv4.2uw$UNAME_VERSION ;; i*86:OS/2:*:*) # If we were able to find `uname', then EMX Unix compatibility # is probably installed. GUESS=$UNAME_MACHINE-pc-os2-emx ;; i*86:XTS-300:*:STOP) GUESS=$UNAME_MACHINE-unknown-stop ;; i*86:atheos:*:*) GUESS=$UNAME_MACHINE-unknown-atheos ;; i*86:syllable:*:*) GUESS=$UNAME_MACHINE-pc-syllable ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) GUESS=i386-unknown-lynxos$UNAME_RELEASE ;; i*86:*DOS:*:*) GUESS=$UNAME_MACHINE-pc-msdosdjgpp ;; i*86:*:4.*:*) UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'` if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then GUESS=$UNAME_MACHINE-univel-sysv$UNAME_REL else GUESS=$UNAME_MACHINE-pc-sysv$UNAME_REL fi ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in *486*) UNAME_MACHINE=i486 ;; *Pentium) UNAME_MACHINE=i586 ;; *Pent*|*Celeron) UNAME_MACHINE=i686 ;; esac GUESS=$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} ;; i*86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ && UNAME_MACHINE=i586 (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ && UNAME_MACHINE=i686 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ && UNAME_MACHINE=i686 GUESS=$UNAME_MACHINE-pc-sco$UNAME_REL else GUESS=$UNAME_MACHINE-pc-sysv32 fi ;; pc:*:*:*) # Left here for compatibility: # uname -m prints for DJGPP always 'pc', but it prints nothing about # the processor, so we play safe by assuming i586. # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configure will decide that # this is a cross-build. GUESS=i586-pc-msdosdjgpp ;; Intel:Mach:3*:*) GUESS=i386-pc-mach3 ;; paragon:*:*:*) GUESS=i860-intel-osf1 ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then GUESS=i860-stardent-sysv$UNAME_RELEASE # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. GUESS=i860-unknown-sysv$UNAME_RELEASE # Unknown i860-SVR4 fi ;; mini*:CTIX:SYS*5:*) # "miniframe" GUESS=m68010-convergent-sysv ;; mc68k:UNIX:SYSTEM5:3.51m) GUESS=m68k-convergent-sysv ;; M680?0:D-NIX:5.3:*) GUESS=m68k-diab-dnix ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) OS_REL='' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3"$OS_REL"; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4; exit; } ;; NCR*:*:4.2:* | MPRAS*:*:4.2:*) OS_REL='.3' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3"$OS_REL"; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) GUESS=m68k-unknown-lynxos$UNAME_RELEASE ;; mc68030:UNIX_System_V:4.*:*) GUESS=m68k-atari-sysv4 ;; TSUNAMI:LynxOS:2.*:*) GUESS=sparc-unknown-lynxos$UNAME_RELEASE ;; rs6000:LynxOS:2.*:*) GUESS=rs6000-unknown-lynxos$UNAME_RELEASE ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) GUESS=powerpc-unknown-lynxos$UNAME_RELEASE ;; SM[BE]S:UNIX_SV:*:*) GUESS=mips-dde-sysv$UNAME_RELEASE ;; RM*:ReliantUNIX-*:*:*) GUESS=mips-sni-sysv4 ;; RM*:SINIX-*:*:*) GUESS=mips-sni-sysv4 ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` GUESS=$UNAME_MACHINE-sni-sysv4 else GUESS=ns32k-sni-sysv fi ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says GUESS=i586-unisys-sysv4 ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm GUESS=hppa1.1-stratus-sysv4 ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. GUESS=i860-stratus-sysv4 ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. GUESS=$UNAME_MACHINE-stratus-vos ;; *:VOS:*:*) # From Paul.Green@stratus.com. GUESS=hppa1.1-stratus-vos ;; mc68*:A/UX:*:*) GUESS=m68k-apple-aux$UNAME_RELEASE ;; news*:NEWS-OS:6*:*) GUESS=mips-sony-newsos6 ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) if test -d /usr/nec; then GUESS=mips-nec-sysv$UNAME_RELEASE else GUESS=mips-unknown-sysv$UNAME_RELEASE fi ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. GUESS=powerpc-be-beos ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. GUESS=powerpc-apple-beos ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. GUESS=i586-pc-beos ;; BePC:Haiku:*:*) # Haiku running on Intel PC compatible. GUESS=i586-pc-haiku ;; x86_64:Haiku:*:*) GUESS=x86_64-unknown-haiku ;; SX-4:SUPER-UX:*:*) GUESS=sx4-nec-superux$UNAME_RELEASE ;; SX-5:SUPER-UX:*:*) GUESS=sx5-nec-superux$UNAME_RELEASE ;; SX-6:SUPER-UX:*:*) GUESS=sx6-nec-superux$UNAME_RELEASE ;; SX-7:SUPER-UX:*:*) GUESS=sx7-nec-superux$UNAME_RELEASE ;; SX-8:SUPER-UX:*:*) GUESS=sx8-nec-superux$UNAME_RELEASE ;; SX-8R:SUPER-UX:*:*) GUESS=sx8r-nec-superux$UNAME_RELEASE ;; SX-ACE:SUPER-UX:*:*) GUESS=sxace-nec-superux$UNAME_RELEASE ;; Power*:Rhapsody:*:*) GUESS=powerpc-apple-rhapsody$UNAME_RELEASE ;; *:Rhapsody:*:*) GUESS=$UNAME_MACHINE-apple-rhapsody$UNAME_RELEASE ;; arm64:Darwin:*:*) GUESS=aarch64-apple-darwin$UNAME_RELEASE ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` case $UNAME_PROCESSOR in unknown) UNAME_PROCESSOR=powerpc ;; esac if command -v xcode-select > /dev/null 2> /dev/null && \ ! xcode-select --print-path > /dev/null 2> /dev/null ; then # Avoid executing cc if there is no toolchain installed as # cc will be a stub that puts up a graphical alert # prompting the user to install developer tools. CC_FOR_BUILD=no_compiler_found else set_cc_for_build fi if test "$CC_FOR_BUILD" != no_compiler_found; then if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then case $UNAME_PROCESSOR in i386) UNAME_PROCESSOR=x86_64 ;; powerpc) UNAME_PROCESSOR=powerpc64 ;; esac fi # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_PPC >/dev/null then UNAME_PROCESSOR=powerpc fi elif test "$UNAME_PROCESSOR" = i386 ; then # uname -m returns i386 or x86_64 UNAME_PROCESSOR=$UNAME_MACHINE fi GUESS=$UNAME_PROCESSOR-apple-darwin$UNAME_RELEASE ;; *:procnto*:*:* | *:QNX:[0123456789]*:*) UNAME_PROCESSOR=`uname -p` if test "$UNAME_PROCESSOR" = x86; then UNAME_PROCESSOR=i386 UNAME_MACHINE=pc fi GUESS=$UNAME_PROCESSOR-$UNAME_MACHINE-nto-qnx$UNAME_RELEASE ;; *:QNX:*:4*) GUESS=i386-pc-qnx ;; NEO-*:NONSTOP_KERNEL:*:*) GUESS=neo-tandem-nsk$UNAME_RELEASE ;; NSE-*:NONSTOP_KERNEL:*:*) GUESS=nse-tandem-nsk$UNAME_RELEASE ;; NSR-*:NONSTOP_KERNEL:*:*) GUESS=nsr-tandem-nsk$UNAME_RELEASE ;; NSV-*:NONSTOP_KERNEL:*:*) GUESS=nsv-tandem-nsk$UNAME_RELEASE ;; NSX-*:NONSTOP_KERNEL:*:*) GUESS=nsx-tandem-nsk$UNAME_RELEASE ;; *:NonStop-UX:*:*) GUESS=mips-compaq-nonstopux ;; BS2000:POSIX*:*:*) GUESS=bs2000-siemens-sysv ;; DS/*:UNIX_System_V:*:*) GUESS=$UNAME_MACHINE-$UNAME_SYSTEM-$UNAME_RELEASE ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. if test "${cputype-}" = 386; then UNAME_MACHINE=i386 elif test "x${cputype-}" != x; then UNAME_MACHINE=$cputype fi GUESS=$UNAME_MACHINE-unknown-plan9 ;; *:TOPS-10:*:*) GUESS=pdp10-unknown-tops10 ;; *:TENEX:*:*) GUESS=pdp10-unknown-tenex ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) GUESS=pdp10-dec-tops20 ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) GUESS=pdp10-xkl-tops20 ;; *:TOPS-20:*:*) GUESS=pdp10-unknown-tops20 ;; *:ITS:*:*) GUESS=pdp10-unknown-its ;; SEI:*:*:SEIUX) GUESS=mips-sei-seiux$UNAME_RELEASE ;; *:DragonFly:*:*) DRAGONFLY_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` GUESS=$UNAME_MACHINE-unknown-dragonfly$DRAGONFLY_REL ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` case $UNAME_MACHINE in A*) GUESS=alpha-dec-vms ;; I*) GUESS=ia64-dec-vms ;; V*) GUESS=vax-dec-vms ;; esac ;; *:XENIX:*:SysV) GUESS=i386-pc-xenix ;; i*86:skyos:*:*) SKYOS_REL=`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'` GUESS=$UNAME_MACHINE-pc-skyos$SKYOS_REL ;; i*86:rdos:*:*) GUESS=$UNAME_MACHINE-pc-rdos ;; i*86:Fiwix:*:*) GUESS=$UNAME_MACHINE-pc-fiwix ;; *:AROS:*:*) GUESS=$UNAME_MACHINE-unknown-aros ;; x86_64:VMkernel:*:*) GUESS=$UNAME_MACHINE-unknown-esx ;; amd64:Isilon\ OneFS:*:*) GUESS=x86_64-unknown-onefs ;; *:Unleashed:*:*) GUESS=$UNAME_MACHINE-unknown-unleashed$UNAME_RELEASE ;; esac # Do we have a guess based on uname results? if test "x$GUESS" != x; then echo "$GUESS" exit fi # No uname command or uname output not recognized. set_cc_for_build cat > "$dummy.c" < #include #endif #if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__) #if defined (vax) || defined (__vax) || defined (__vax__) || defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__) #include #if defined(_SIZE_T_) || defined(SIGLOST) #include #endif #endif #endif main () { #if defined (sony) #if defined (MIPSEB) /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, I don't know.... */ printf ("mips-sony-bsd\n"); exit (0); #else #include printf ("m68k-sony-newsos%s\n", #ifdef NEWSOS4 "4" #else "" #endif ); exit (0); #endif #endif #if defined (NeXT) #if !defined (__ARCHITECTURE__) #define __ARCHITECTURE__ "m68k" #endif int version; version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; if (version < 4) printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); else printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); exit (0); #endif #if defined (MULTIMAX) || defined (n16) #if defined (UMAXV) printf ("ns32k-encore-sysv\n"); exit (0); #else #if defined (CMU) printf ("ns32k-encore-mach\n"); exit (0); #else printf ("ns32k-encore-bsd\n"); exit (0); #endif #endif #endif #if defined (__386BSD__) printf ("i386-pc-bsd\n"); exit (0); #endif #if defined (sequent) #if defined (i386) printf ("i386-sequent-dynix\n"); exit (0); #endif #if defined (ns32000) printf ("ns32k-sequent-dynix\n"); exit (0); #endif #endif #if defined (_SEQUENT_) struct utsname un; uname(&un); if (strncmp(un.version, "V2", 2) == 0) { printf ("i386-sequent-ptx2\n"); exit (0); } if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ printf ("i386-sequent-ptx1\n"); exit (0); } printf ("i386-sequent-ptx\n"); exit (0); #endif #if defined (vax) #if !defined (ultrix) #include #if defined (BSD) #if BSD == 43 printf ("vax-dec-bsd4.3\n"); exit (0); #else #if BSD == 199006 printf ("vax-dec-bsd4.3reno\n"); exit (0); #else printf ("vax-dec-bsd\n"); exit (0); #endif #endif #else printf ("vax-dec-bsd\n"); exit (0); #endif #else #if defined(_SIZE_T_) || defined(SIGLOST) struct utsname un; uname (&un); printf ("vax-dec-ultrix%s\n", un.release); exit (0); #else printf ("vax-dec-ultrix\n"); exit (0); #endif #endif #endif #if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__) #if defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__) #if defined(_SIZE_T_) || defined(SIGLOST) struct utsname *un; uname (&un); printf ("mips-dec-ultrix%s\n", un.release); exit (0); #else printf ("mips-dec-ultrix\n"); exit (0); #endif #endif #endif #if defined (alliant) && defined (i860) printf ("i860-alliant-bsd\n"); exit (0); #endif exit (1); } EOF $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null && SYSTEM_NAME=`"$dummy"` && { echo "$SYSTEM_NAME"; exit; } # Apollos put the system type in the environment. test -d /usr/apollo && { echo "$ISP-apollo-$SYSTYPE"; exit; } echo "$0: unable to guess system type" >&2 case $UNAME_MACHINE:$UNAME_SYSTEM in mips:Linux | mips64:Linux) # If we got here on MIPS GNU/Linux, output extra information. cat >&2 <&2 <&2 </dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` /bin/uname -X = `(/bin/uname -X) 2>/dev/null` hostinfo = `(hostinfo) 2>/dev/null` /bin/universe = `(/bin/universe) 2>/dev/null` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` /bin/arch = `(/bin/arch) 2>/dev/null` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` UNAME_MACHINE = "$UNAME_MACHINE" UNAME_RELEASE = "$UNAME_RELEASE" UNAME_SYSTEM = "$UNAME_SYSTEM" UNAME_VERSION = "$UNAME_VERSION" EOF fi exit 1 # Local variables: # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: memcached-1.6.20/memcached.h0000664000175000017500000011523714427543277012540 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ /** \file * The main memcached header holding commonly used data * structures and function prototypes. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include #include #include #include #include #include #include #include /* need this to get IOV_MAX on some platforms. */ #ifndef __need_IOV_MAX #define __need_IOV_MAX #endif #include /* FreeBSD 4.x doesn't have IOV_MAX exposed. */ #ifndef IOV_MAX #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__GNU__) # define IOV_MAX 1024 /* GNU/Hurd don't set MAXPATHLEN * http://www.gnu.org/software/hurd/hurd/porting/guidelines.html#PATH_MAX_tt_MAX_PATH_tt_MAXPATHL */ #ifndef MAXPATHLEN #define MAXPATHLEN 4096 #endif #endif #endif #if defined(__linux__) # define SOCK_COOKIE_ID SO_MARK #elif defined(__FreeBSD__) # define SOCK_COOKIE_ID SO_USER_COOKIE #elif defined(__OpenBSD__) # define SOCK_COOKIE_ID SO_RTABLE #endif #include "itoa_ljust.h" #include "protocol_binary.h" #include "cache.h" #include "logger.h" #ifdef EXTSTORE #include "crc32c.h" #endif #include "sasl_defs.h" #ifdef TLS #include #endif /* for NAPI pinning feature */ #ifndef SO_INCOMING_NAPI_ID #define SO_INCOMING_NAPI_ID 56 #endif /** Maximum length of a key. */ #define KEY_MAX_LENGTH 250 /** Maximum length of a uri encoded key. */ #define KEY_MAX_URI_ENCODED_LENGTH (KEY_MAX_LENGTH * 3 + 1) /** Size of an incr buf. */ #define INCR_MAX_STORAGE_LEN 24 #define WRITE_BUFFER_SIZE 1024 #define READ_BUFFER_SIZE 16384 #define READ_BUFFER_CACHED 0 #define UDP_READ_BUFFER_SIZE 65536 #define UDP_MAX_PAYLOAD_SIZE 1400 #define UDP_HEADER_SIZE 8 #define UDP_DATA_SIZE 1392 // UDP_MAX_PAYLOAD_SIZE - UDP_HEADER_SIZE #define MAX_SENDBUF_SIZE (256 * 1024 * 1024) /* Binary protocol stuff */ #define BIN_MAX_EXTLEN 20 // length of the _incr command is currently the longest. /* Initial power multiplier for the hash table */ #define HASHPOWER_DEFAULT 16 #define HASHPOWER_MAX 32 /* * We only reposition items in the LRU queue if they haven't been repositioned * in this many seconds. That saves us from churning on frequently-accessed * items. */ #define ITEM_UPDATE_INTERVAL 60 /* * Valid range of the maximum size of an item, in bytes. */ #define ITEM_SIZE_MAX_LOWER_LIMIT 1024 #define ITEM_SIZE_MAX_UPPER_LIMIT 1024 * 1024 * 1024 /* Slab sizing definitions. */ #define POWER_SMALLEST 1 #define POWER_LARGEST 256 /* actual cap is 255 */ #define SLAB_GLOBAL_PAGE_POOL 0 /* magic slab class for storing pages for reassignment */ #define CHUNK_ALIGN_BYTES 8 /* slab class max is a 6-bit number, -1. */ #define MAX_NUMBER_OF_SLAB_CLASSES (63 + 1) /** How long an object can reasonably be assumed to be locked before harvesting it on a low memory condition. Default: disabled. */ #define TAIL_REPAIR_TIME_DEFAULT 0 /* warning: don't use these macros with a function, as it evals its arg twice */ #define ITEM_get_cas(i) (((i)->it_flags & ITEM_CAS) ? \ (i)->data->cas : (uint64_t)0) #define ITEM_set_cas(i,v) { \ if ((i)->it_flags & ITEM_CAS) { \ (i)->data->cas = v; \ } \ } #define ITEM_key(item) (((char*)&((item)->data)) \ + (((item)->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0)) #define ITEM_suffix(item) ((char*) &((item)->data) + (item)->nkey + 1 \ + (((item)->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0)) #define ITEM_data(item) ((char*) &((item)->data) + (item)->nkey + 1 \ + (((item)->it_flags & ITEM_CFLAGS) ? sizeof(uint32_t) : 0) \ + (((item)->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0)) #define ITEM_ntotal(item) (sizeof(struct _stritem) + (item)->nkey + 1 \ + (item)->nbytes \ + (((item)->it_flags & ITEM_CFLAGS) ? sizeof(uint32_t) : 0) \ + (((item)->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0)) #define ITEM_clsid(item) ((item)->slabs_clsid & ~(3<<6)) #define ITEM_lruid(item) ((item)->slabs_clsid & (3<<6)) #define STAT_KEY_LEN 128 #define STAT_VAL_LEN 128 /** Append a simple stat with a stat name, value format and value */ #define APPEND_STAT(name, fmt, val) \ append_stat(name, add_stats, c, fmt, val); /** Append an indexed stat with a stat name (with format), value format and value */ #define APPEND_NUM_FMT_STAT(name_fmt, num, name, fmt, val) \ klen = snprintf(key_str, STAT_KEY_LEN, name_fmt, num, name); \ vlen = snprintf(val_str, STAT_VAL_LEN, fmt, val); \ add_stats(key_str, klen, val_str, vlen, c); /** Common APPEND_NUM_FMT_STAT format. */ #define APPEND_NUM_STAT(num, name, fmt, val) \ APPEND_NUM_FMT_STAT("%d:%s", num, name, fmt, val) /** Item client flag conversion */ #define FLAGS_CONV(it, flag) { \ if ((it)->it_flags & ITEM_CFLAGS) { \ flag = *((uint32_t *)ITEM_suffix((it))); \ } else { \ flag = 0; \ } \ } #define FLAGS_SIZE(item) (((item)->it_flags & ITEM_CFLAGS) ? sizeof(uint32_t) : 0) /** * Callback for any function producing stats. * * @param key the stat's key * @param klen length of the key * @param val the stat's value in an ascii form (e.g. text form of a number) * @param vlen length of the value * @parm cookie magic callback cookie */ typedef void (*ADD_STAT)(const char *key, const uint16_t klen, const char *val, const uint32_t vlen, const void *cookie); /* * NOTE: If you modify this table you _MUST_ update the function state_text */ /** * Possible states of a connection. */ enum conn_states { conn_listening, /**< the socket which listens for connections */ conn_new_cmd, /**< Prepare connection for next command */ conn_waiting, /**< waiting for a readable socket */ conn_read, /**< reading in a command line */ conn_parse_cmd, /**< try to parse a command from the input buffer */ conn_write, /**< writing out a simple response */ conn_nread, /**< reading in a fixed number of bytes */ conn_swallow, /**< swallowing unnecessary bytes w/o storing */ conn_closing, /**< closing this connection */ conn_mwrite, /**< writing out many items sequentially */ conn_closed, /**< connection is closed */ conn_watch, /**< held by the logger thread as a watcher */ conn_io_queue, /**< wait on async. process to get response object */ conn_max_state /**< Max state value (used for assertion) */ }; enum bin_substates { bin_no_state, bin_reading_set_header, bin_reading_cas_header, bin_read_set_value, bin_reading_get_key, bin_reading_stat, bin_reading_del_header, bin_reading_incr_header, bin_read_flush_exptime, bin_reading_sasl_auth, bin_reading_sasl_auth_data, bin_reading_touch_key, }; enum protocol { ascii_prot = 3, /* arbitrary value. */ binary_prot, negotiating_prot, /* Discovering the protocol */ #ifdef PROXY proxy_prot, #endif }; enum network_transport { local_transport, /* Unix sockets*/ tcp_transport, udp_transport }; enum pause_thread_types { PAUSE_WORKER_THREADS = 0, PAUSE_ALL_THREADS, RESUME_ALL_THREADS, RESUME_WORKER_THREADS }; enum stop_reasons { NOT_STOP, GRACE_STOP, EXIT_NORMALLY }; enum close_reasons { ERROR_CLOSE, NORMAL_CLOSE, IDLE_TIMEOUT_CLOSE, SHUTDOWN_CLOSE, }; #define IS_TCP(x) (x == tcp_transport) #define IS_UDP(x) (x == udp_transport) #define NREAD_ADD 1 #define NREAD_SET 2 #define NREAD_REPLACE 3 #define NREAD_APPEND 4 #define NREAD_PREPEND 5 #define NREAD_CAS 6 #define NREAD_APPENDVIV 7 // specific to meta #define NREAD_PREPENDVIV 8 // specific to meta #define CAS_ALLOW_STALE true #define CAS_NO_STALE false #define LOG_TYPE_DELETE 1 #define LOG_TYPE_META_DELETE 2 enum store_item_type { NOT_STORED=0, STORED, EXISTS, NOT_FOUND, TOO_LARGE, NO_MEMORY }; enum delta_result_type { OK, NON_NUMERIC, EOM, DELTA_ITEM_NOT_FOUND, DELTA_ITEM_CAS_MISMATCH }; /** Time relative to server start. Smaller than time_t on 64-bit systems. */ // TODO: Move to sub-header. needed in logger.h //typedef unsigned int rel_time_t; /** Use X macros to avoid iterating over the stats fields during reset and * aggregation. No longer have to add new stats in 3+ places. */ #define SLAB_STATS_FIELDS \ X(set_cmds) \ X(get_hits) \ X(touch_hits) \ X(delete_hits) \ X(cas_hits) \ X(cas_badval) \ X(incr_hits) \ X(decr_hits) /** Stats stored per slab (and per thread). */ struct slab_stats { #define X(name) uint64_t name; SLAB_STATS_FIELDS #undef X }; #define THREAD_STATS_FIELDS \ X(get_cmds) \ X(get_misses) \ X(get_expired) \ X(get_flushed) \ X(touch_cmds) \ X(touch_misses) \ X(delete_misses) \ X(incr_misses) \ X(decr_misses) \ X(cas_misses) \ X(meta_cmds) \ X(bytes_read) \ X(bytes_written) \ X(flush_cmds) \ X(conn_yields) /* # of yields for connections (-R option)*/ \ X(auth_cmds) \ X(auth_errors) \ X(idle_kicks) /* idle connections killed */ \ X(response_obj_oom) \ X(response_obj_count) \ X(response_obj_bytes) \ X(read_buf_oom) \ X(store_too_large) \ X(store_no_memory) #ifdef EXTSTORE #define EXTSTORE_THREAD_STATS_FIELDS \ X(get_extstore) \ X(get_aborted_extstore) \ X(get_oom_extstore) \ X(recache_from_extstore) \ X(miss_from_extstore) \ X(badcrc_from_extstore) #endif #ifdef PROXY #define PROXY_THREAD_STATS_FIELDS \ X(proxy_conn_requests) \ X(proxy_conn_errors) \ X(proxy_conn_oom) \ X(proxy_req_active) \ X(proxy_await_active) #endif /** * Stats stored per-thread. */ struct thread_stats { pthread_mutex_t mutex; #define X(name) uint64_t name; THREAD_STATS_FIELDS #ifdef EXTSTORE EXTSTORE_THREAD_STATS_FIELDS #endif #ifdef PROXY PROXY_THREAD_STATS_FIELDS #endif #undef X struct slab_stats slab_stats[MAX_NUMBER_OF_SLAB_CLASSES]; uint64_t lru_hits[POWER_LARGEST]; uint64_t read_buf_count; uint64_t read_buf_bytes; uint64_t read_buf_bytes_free; }; /** * Global stats. Only resettable stats should go into this structure. */ struct stats { uint64_t total_items; uint64_t total_conns; uint64_t rejected_conns; uint64_t malloc_fails; uint64_t listen_disabled_num; uint64_t slabs_moved; /* times slabs were moved around */ uint64_t slab_reassign_rescues; /* items rescued during slab move */ uint64_t slab_reassign_evictions_nomem; /* valid items lost during slab move */ uint64_t slab_reassign_inline_reclaim; /* valid items lost during slab move */ uint64_t slab_reassign_chunk_rescues; /* chunked-item chunks recovered */ uint64_t slab_reassign_busy_items; /* valid temporarily unmovable */ uint64_t slab_reassign_busy_deletes; /* refcounted items killed */ uint64_t lru_crawler_starts; /* Number of item crawlers kicked off */ uint64_t lru_maintainer_juggles; /* number of LRU bg pokes */ uint64_t time_in_listen_disabled_us; /* elapsed time in microseconds while server unable to process new connections */ uint64_t log_worker_dropped; /* logs dropped by worker threads */ uint64_t log_worker_written; /* logs written by worker threads */ uint64_t log_watcher_skipped; /* logs watchers missed */ uint64_t log_watcher_sent; /* logs sent to watcher buffers */ #ifdef EXTSTORE uint64_t extstore_compact_lost; /* items lost because they were locked */ uint64_t extstore_compact_rescues; /* items re-written during compaction */ uint64_t extstore_compact_skipped; /* unhit items skipped during compaction */ #endif #ifdef TLS uint64_t ssl_handshake_errors; /* TLS failures at accept/handshake time */ uint64_t ssl_new_sessions; /* successfully negotiated new (non-reused) TLS sessions */ #endif struct timeval maxconns_entered; /* last time maxconns entered */ uint64_t unexpected_napi_ids; /* see doc/napi_ids.txt */ uint64_t round_robin_fallback; /* see doc/napi_ids.txt */ }; /** * Global "state" stats. Reflects state that shouldn't be wiped ever. * Ordered for some cache line locality for commonly updated counters. */ struct stats_state { uint64_t curr_items; uint64_t curr_bytes; uint64_t curr_conns; uint64_t hash_bytes; /* size used for hash tables */ unsigned int conn_structs; unsigned int reserved_fds; unsigned int hash_power_level; /* Better hope it's not over 9000 */ unsigned int log_watchers; /* number of currently active watchers */ bool hash_is_expanding; /* If the hash table is being expanded */ bool accepting_conns; /* whether we are currently accepting */ bool slab_reassign_running; /* slab reassign in progress */ bool lru_crawler_running; /* crawl in progress */ }; #define MAX_VERBOSITY_LEVEL 2 /* When adding a setting, be sure to update process_stat_settings */ /** * Globally accessible settings as derived from the commandline. */ struct settings { size_t maxbytes; int maxconns; int port; int udpport; char *inter; int verbose; rel_time_t oldest_live; /* ignore existing items older than this */ uint64_t oldest_cas; /* ignore existing items with CAS values lower than this */ int evict_to_free; char *socketpath; /* path to unix socket if using local socket */ char *auth_file; /* path to user authentication file */ int access; /* access mask (a la chmod) for unix domain socket */ double factor; /* chunk size growth factor */ int chunk_size; int num_threads; /* number of worker (without dispatcher) libevent threads to run */ int num_threads_per_udp; /* number of worker threads serving each udp socket */ char prefix_delimiter; /* character that marks a key prefix (for stats) */ int detail_enabled; /* nonzero if we're collecting detailed stats */ int reqs_per_event; /* Maximum number of io to process on each io-event. */ bool use_cas; enum protocol binding_protocol; int backlog; int item_size_max; /* Maximum item size */ int slab_chunk_size_max; /* Upper end for chunks within slab pages. */ int slab_page_size; /* Slab's page units. */ volatile sig_atomic_t sig_hup; /* a HUP signal was received but not yet handled */ bool sasl; /* SASL on/off */ bool maxconns_fast; /* Whether or not to early close connections */ bool lru_crawler; /* Whether or not to enable the autocrawler thread */ bool lru_maintainer_thread; /* LRU maintainer background thread */ bool lru_segmented; /* Use split or flat LRU's */ bool slab_reassign; /* Whether or not slab reassignment is allowed */ int slab_automove; /* Whether or not to automatically move slabs */ double slab_automove_ratio; /* youngest must be within pct of oldest */ unsigned int slab_automove_window; /* window mover for algorithm */ int hashpower_init; /* Starting hash power level */ bool shutdown_command; /* allow shutdown command */ int tail_repair_time; /* LRU tail refcount leak repair time */ bool flush_enabled; /* flush_all enabled */ bool dump_enabled; /* whether cachedump/metadump commands work */ char *hash_algorithm; /* Hash algorithm in use */ int lru_crawler_sleep; /* Microsecond sleep between items */ uint32_t lru_crawler_tocrawl; /* Number of items to crawl per run */ int hot_lru_pct; /* percentage of slab space for HOT_LRU */ int warm_lru_pct; /* percentage of slab space for WARM_LRU */ double hot_max_factor; /* HOT tail age relative to COLD tail */ double warm_max_factor; /* WARM tail age relative to COLD tail */ int crawls_persleep; /* Number of LRU crawls to run before sleeping */ bool temp_lru; /* TTL < temporary_ttl uses TEMP_LRU */ uint32_t temporary_ttl; /* temporary LRU threshold */ int idle_timeout; /* Number of seconds to let connections idle */ unsigned int logger_watcher_buf_size; /* size of logger's per-watcher buffer */ unsigned int logger_buf_size; /* size of per-thread logger buffer */ unsigned int read_buf_mem_limit; /* total megabytes allowable for net buffers */ bool drop_privileges; /* Whether or not to drop unnecessary process privileges */ bool watch_enabled; /* allows watch commands to be dropped */ bool relaxed_privileges; /* Relax process restrictions when running testapp */ #ifdef EXTSTORE unsigned int ext_io_threadcount; /* number of IO threads to run. */ unsigned int ext_page_size; /* size in megabytes of storage pages. */ unsigned int ext_item_size; /* minimum size of items to store externally */ unsigned int ext_item_age; /* max age of tail item before storing ext. */ unsigned int ext_low_ttl; /* remaining TTL below this uses own pages */ unsigned int ext_recache_rate; /* counter++ % recache_rate == 0 > recache */ unsigned int ext_wbuf_size; /* read only note for the engine */ unsigned int ext_compact_under; /* when fewer than this many pages, compact */ unsigned int ext_drop_under; /* when fewer than this many pages, drop COLD items */ unsigned int ext_max_sleep; /* maximum sleep time for extstore bg threads, in us */ double ext_max_frag; /* ideal maximum page fragmentation */ double slab_automove_freeratio; /* % of memory to hold free as buffer */ bool ext_drop_unread; /* skip unread items during compaction */ /* start flushing to extstore after memory below this */ unsigned int ext_global_pool_min; #endif #ifdef TLS bool ssl_enabled; /* indicates whether SSL is enabled */ SSL_CTX *ssl_ctx; /* holds the SSL server context which has the server certificate */ char *ssl_chain_cert; /* path to the server SSL chain certificate */ char *ssl_key; /* path to the server key */ int ssl_verify_mode; /* client certificate verify mode */ int ssl_keyformat; /* key format , default is PEM */ char *ssl_ciphers; /* list of SSL ciphers */ char *ssl_ca_cert; /* certificate with CAs. */ rel_time_t ssl_last_cert_refresh_time; /* time of the last server certificate refresh */ unsigned int ssl_wbuf_size; /* size of the write buffer used by ssl_sendmsg method */ bool ssl_session_cache; /* enable SSL server session caching */ bool ssl_kernel_tls; /* enable server kTLS */ int ssl_min_version; /* minimum SSL protocol version to accept */ #endif int num_napi_ids; /* maximum number of NAPI IDs */ char *memory_file; /* warm restart memory file path */ #ifdef PROXY bool proxy_enabled; bool proxy_uring; /* if the proxy should use io_uring */ char *proxy_startfile; /* lua file to run when workers start */ void *proxy_ctx; /* proxy's state context */ #endif #ifdef SOCK_COOKIE_ID uint32_t sock_cookie_id; #endif }; extern struct stats stats; extern struct stats_state stats_state; extern time_t process_started; extern struct settings settings; #define ITEM_LINKED 1 #define ITEM_CAS 2 /* temp */ #define ITEM_SLABBED 4 /* Item was fetched at least once in its lifetime */ #define ITEM_FETCHED 8 /* Appended on fetch, removed on LRU shuffling */ #define ITEM_ACTIVE 16 /* If an item's storage are chained chunks. */ #define ITEM_CHUNKED 32 #define ITEM_CHUNK 64 /* ITEM_data bulk is external to item */ #define ITEM_HDR 128 /* additional 4 bytes for item client flags */ #define ITEM_CFLAGS 256 /* item has sent out a token already */ #define ITEM_TOKEN_SENT 512 /* reserved, in case tokens should be a 2-bit count in future */ #define ITEM_TOKEN_RESERVED 1024 /* if item has been marked as a stale value */ #define ITEM_STALE 2048 /* if item key was sent in binary */ #define ITEM_KEY_BINARY 4096 /** * Structure for storing items within memcached. */ typedef struct _stritem { /* Protected by LRU locks */ struct _stritem *next; struct _stritem *prev; /* Rest are protected by an item lock */ struct _stritem *h_next; /* hash chain next */ rel_time_t time; /* least recent access */ rel_time_t exptime; /* expire time */ int nbytes; /* size of data */ unsigned short refcount; uint16_t it_flags; /* ITEM_* above */ uint8_t slabs_clsid;/* which slab class we're in */ uint8_t nkey; /* key length, w/terminating null and padding */ /* this odd type prevents type-punning issues when we do * the little shuffle to save space when not using CAS. */ union { uint64_t cas; char end; } data[]; /* if it_flags & ITEM_CAS we have 8 bytes CAS */ /* then null-terminated key */ /* then " flags length\r\n" (no terminating null) */ /* then data with terminating \r\n (no terminating null; it's binary!) */ } item; // TODO: If we eventually want user loaded modules, we can't use an enum :( enum crawler_run_type { CRAWLER_AUTOEXPIRE=0, CRAWLER_EXPIRED, CRAWLER_METADUMP, CRAWLER_MGDUMP }; typedef struct { struct _stritem *next; struct _stritem *prev; struct _stritem *h_next; /* hash chain next */ rel_time_t time; /* least recent access */ rel_time_t exptime; /* expire time */ int nbytes; /* size of data */ unsigned short refcount; uint16_t it_flags; /* ITEM_* above */ uint8_t slabs_clsid;/* which slab class we're in */ uint8_t nkey; /* key length, w/terminating null and padding */ uint32_t remaining; /* Max keys to crawl per slab per invocation */ uint64_t reclaimed; /* items reclaimed during this crawl. */ uint64_t unfetched; /* items reclaimed unfetched during this crawl. */ uint64_t checked; /* items examined during this crawl. */ } crawler; /* Header when an item is actually a chunk of another item. */ typedef struct _strchunk { struct _strchunk *next; /* points within its own chain. */ struct _strchunk *prev; /* can potentially point to the head. */ struct _stritem *head; /* always points to the owner chunk */ int size; /* available chunk space in bytes */ int used; /* chunk space used */ int nbytes; /* used. */ unsigned short refcount; /* used? */ uint16_t it_flags; /* ITEM_* above. */ uint8_t slabs_clsid; /* Same as above. */ uint8_t orig_clsid; /* For obj hdr chunks slabs_clsid is fake. */ char data[]; } item_chunk; #ifdef NEED_ALIGN static inline char *ITEM_schunk(item *it) { int offset = it->nkey + 1 + ((it->it_flags & ITEM_CFLAGS) ? sizeof(uint32_t) : 0) + ((it->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0); int remain = offset % 8; if (remain != 0) { offset += 8 - remain; } return ((char *) &(it->data)) + offset; } #else #define ITEM_schunk(item) ((char*) &((item)->data) + (item)->nkey + 1 \ + (((item)->it_flags & ITEM_CFLAGS) ? sizeof(uint32_t) : 0) \ + (((item)->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0)) #endif #ifdef EXTSTORE typedef struct { unsigned int page_version; /* from IO header */ unsigned int offset; /* from IO header */ unsigned short page_id; /* from IO header */ } item_hdr; #endif #define IO_QUEUE_COUNT 3 #define IO_QUEUE_NONE 0 #define IO_QUEUE_EXTSTORE 1 #define IO_QUEUE_PROXY 2 typedef struct _io_pending_t io_pending_t; typedef struct io_queue_s io_queue_t; typedef void (*io_queue_stack_cb)(io_queue_t *q); typedef void (*io_queue_cb)(io_pending_t *pending); // This structure used to be passed between threads, but is now owned entirely // by the worker threads. // IO pending objects are created and stacked into this structure. They are // then sent off to remote threads. // The objects are returned one at a time to the worker threads, and this // structure is then consulted to see when to resume the worker. struct io_queue_s { void *ctx; // duplicated from io_queue_cb_t void *stack_ctx; // module-specific context to be batch-submitted int count; // ios to process before returning. only accessed by queue processor once submitted int type; // duplicated from io_queue_cb_t }; typedef struct io_queue_cb_s { void *ctx; // untouched ptr for specific context io_queue_stack_cb submit_cb; // callback given a full stack of pending IO's at once. int type; } io_queue_cb_t; typedef struct _mc_resp_bundle mc_resp_bundle; typedef struct { pthread_t thread_id; /* unique ID of this thread */ struct event_base *base; /* libevent handle this thread uses */ struct event notify_event; /* listen event for notify pipe */ #ifdef HAVE_EVENTFD int notify_event_fd; /* notify counter */ #else int notify_receive_fd; /* receiving end of notify pipe */ int notify_send_fd; /* sending end of notify pipe */ #endif int cur_sfd; /* client fd for logging commands */ int thread_baseid; /* which "number" thread this is for data offsets */ struct thread_stats stats; /* Stats generated by this thread */ io_queue_cb_t io_queues[IO_QUEUE_COUNT]; struct conn_queue *ev_queue; /* Worker/conn event queue */ cache_t *rbuf_cache; /* static-sized read buffers */ mc_resp_bundle *open_bundle; cache_t *io_cache; /* IO objects */ #ifdef EXTSTORE void *storage; /* data object for storage system */ #endif logger *l; /* logger buffer */ void *lru_bump_buf; /* async LRU bump buffer */ #ifdef TLS char *ssl_wbuf; #endif int napi_id; /* napi id associated with this thread */ #ifdef PROXY void *proxy_ctx; // proxy global context void *L; // lua VM void *proxy_hooks; void *proxy_user_stats; void *proxy_int_stats; void *proxy_event_thread; // worker threads can also be proxy IO threads pthread_mutex_t proxy_limit_lock; uint64_t proxy_active_req_limit; uint64_t proxy_buffer_memory_limit; // protected by limit_lock uint64_t proxy_buffer_memory_used; // protected by limit_lock uint32_t proxy_rng[4]; // fast per-thread rng for lua. // TODO: add ctx object so we can attach to queue. #endif } LIBEVENT_THREAD; /** * Response objects */ #define MC_RESP_IOVCOUNT 4 typedef struct _mc_resp { mc_resp_bundle *bundle; // ptr back to bundle struct _mc_resp *next; // choo choo. int wbytes; // bytes to write out of wbuf: might be able to nuke this. int tosend; // total bytes to send for this response void *write_and_free; /** free this memory after finishing writing */ io_pending_t *io_pending; /* pending IO descriptor for this response */ item *item; /* item associated with this response object, with reference held */ struct iovec iov[MC_RESP_IOVCOUNT]; /* built-in iovecs to simplify network code */ int chunked_total; /* total amount of chunked item data to send. */ uint8_t iovcnt; uint8_t chunked_data_iov; /* this iov is a pointer to chunked data header */ /* instruct transmit to skip this response object. used by storage engines * to asynchronously kill an object that was queued to write */ bool skip; bool free; // double free detection. // UDP bits. Copied in from the client. uint16_t request_id; /* Incoming UDP request ID, if this is a UDP "connection" */ uint16_t udp_sequence; /* packet counter when transmitting result */ uint16_t udp_total; /* total number of packets in sequence */ struct sockaddr_in6 request_addr; /* udp: Who sent this request */ socklen_t request_addr_size; char wbuf[WRITE_BUFFER_SIZE]; } mc_resp; #define MAX_RESP_PER_BUNDLE ((READ_BUFFER_SIZE - sizeof(mc_resp_bundle)) / sizeof(mc_resp)) struct _mc_resp_bundle { uint8_t refcount; uint8_t next_check; // next object to check on assignment. struct _mc_resp_bundle *next; struct _mc_resp_bundle *prev; mc_resp r[]; }; typedef struct conn conn; struct _io_pending_t { int io_queue_type; // matches one of IO_QUEUE_* LIBEVENT_THREAD *thread; conn *c; mc_resp *resp; // associated response object io_queue_cb return_cb; // called on worker thread. io_queue_cb finalize_cb; // called back on the worker thread. char data[120]; }; /** * The structure representing a connection into memcached. */ struct conn { sasl_conn_t *sasl_conn; int sfd; bool sasl_started; bool authenticated; bool set_stale; bool mset_res; /** uses mset format for return code */ bool close_after_write; /** flush write then move to close connection */ bool rbuf_malloced; /** read buffer was malloc'ed for ascii mget, needs free() */ bool item_malloced; /** item for conn_nread state is a temporary malloc */ #ifdef TLS SSL *ssl; char *ssl_wbuf; bool ssl_enabled; #endif enum conn_states state; enum bin_substates substate; rel_time_t last_cmd_time; struct event event; short ev_flags; short which; /** which events were just triggered */ char *rbuf; /** buffer to read commands into */ char *rcurr; /** but if we parsed some already, this is where we stopped */ int rsize; /** total allocated size of rbuf */ int rbytes; /** how much data, starting from rcur, do we have unparsed */ mc_resp *resp; // tail response. mc_resp *resp_head; // first response in current stack. char *ritem; /** when we read in an item's value, it goes here */ int rlbytes; /** * item is used to hold an item structure created after reading the command * line of set/add/replace commands, but before we finished reading the actual * data. The data is read into ITEM_data(item) to avoid extra copying. */ void *item; /* for commands set/add/replace */ /* data for the swallow state */ int sbytes; /* how many bytes to swallow */ int io_queues_submitted; /* see notes on io_queue_t */ io_queue_t io_queues[IO_QUEUE_COUNT]; /* set of deferred IO queues. */ #ifdef PROXY unsigned int proxy_coro_ref; /* lua reference for active coroutine */ #endif #ifdef EXTSTORE unsigned int recache_counter; #endif enum protocol protocol; /* which protocol this connection speaks */ enum network_transport transport; /* what transport is used by this connection */ enum close_reasons close_reason; /* reason for transition into conn_closing */ /* data for UDP clients */ int request_id; /* Incoming UDP request ID, if this is a UDP "connection" */ struct sockaddr_in6 request_addr; /* udp: Who sent the most recent request */ socklen_t request_addr_size; bool noreply; /* True if the reply should not be sent. */ /* current stats command */ struct { char *buffer; size_t size; size_t offset; } stats; /* Binary protocol stuff */ /* This is where the binary header goes */ protocol_binary_request_header binary_header; uint64_t cas; /* the cas to return */ uint64_t tag; /* listener stocket tag */ short cmd; /* current command being processed */ int opaque; int keylen; conn *next; /* Used for generating a list of conn structures */ LIBEVENT_THREAD *thread; /* Pointer to the thread object serving this connection */ int (*try_read_command)(conn *c); /* pointer for top level input parser */ ssize_t (*read)(conn *c, void *buf, size_t count); ssize_t (*sendmsg)(conn *c, struct msghdr *msg, int flags); ssize_t (*write)(conn *c, void *buf, size_t count); }; /* array of conn structures, indexed by file descriptor */ extern conn **conns; /* current time of day (updated periodically) */ extern volatile rel_time_t current_time; #ifdef MEMCACHED_DEBUG extern volatile bool is_paused; extern volatile int64_t delta; #endif /* TODO: Move to slabs.h? */ extern volatile int slab_rebalance_signal; struct slab_rebalance { void *slab_start; void *slab_end; void *slab_pos; int s_clsid; int d_clsid; uint32_t busy_items; uint32_t rescues; uint32_t evictions_nomem; uint32_t inline_reclaim; uint32_t chunk_rescues; uint32_t busy_deletes; uint32_t busy_loops; uint8_t done; uint8_t *completed; }; extern struct slab_rebalance slab_rebal; #ifdef EXTSTORE extern void *ext_storage; #endif /* * Functions */ void do_accept_new_conns(const bool do_accept); enum delta_result_type do_add_delta(LIBEVENT_THREAD *t, const char *key, const size_t nkey, const bool incr, const int64_t delta, char *buf, uint64_t *cas, const uint32_t hv, item **it_ret); enum store_item_type do_store_item(item *item, int comm, LIBEVENT_THREAD *t, const uint32_t hv, int *nbytes, uint64_t *cas, bool cas_stale); void thread_io_queue_add(LIBEVENT_THREAD *t, int type, void *ctx, io_queue_stack_cb cb); void conn_io_queue_setup(conn *c); io_queue_t *conn_io_queue_get(conn *c, int type); io_queue_cb_t *thread_io_queue_get(LIBEVENT_THREAD *t, int type); void conn_io_queue_return(io_pending_t *io); conn *conn_new(const int sfd, const enum conn_states init_state, const int event_flags, const int read_buffer_size, enum network_transport transport, struct event_base *base, void *ssl, uint64_t conntag, enum protocol bproto); void conn_worker_readd(conn *c); extern int daemonize(int nochdir, int noclose); #define mutex_lock(x) pthread_mutex_lock(x) #define mutex_unlock(x) pthread_mutex_unlock(x) #include "stats_prefix.h" #include "slabs.h" #include "assoc.h" #include "items.h" #include "crawler.h" #include "trace.h" #include "hash.h" #include "util.h" /* * Functions such as the libevent-related calls that need to do cross-thread * communication in multithreaded mode (rather than actually doing the work * in the current thread) are called via "dispatch_" frontends, which are * also #define-d to directly call the underlying code in singlethreaded mode. */ void memcached_thread_init(int nthreads, void *arg); void redispatch_conn(conn *c); void timeout_conn(conn *c); #ifdef PROXY void proxy_reload_notify(LIBEVENT_THREAD *t); #endif void return_io_pending(io_pending_t *io); void dispatch_conn_new(int sfd, enum conn_states init_state, int event_flags, int read_buffer_size, enum network_transport transport, void *ssl, uint64_t conntag, enum protocol bproto); void sidethread_conn_close(conn *c); /* Lock wrappers for cache functions that are called from main loop. */ enum delta_result_type add_delta(LIBEVENT_THREAD *t, const char *key, const size_t nkey, bool incr, const int64_t delta, char *buf, uint64_t *cas); void accept_new_conns(const bool do_accept); void conn_close_idle(conn *c); void conn_close_all(void); item *item_alloc(const char *key, size_t nkey, int flags, rel_time_t exptime, int nbytes); #define DO_UPDATE true #define DONT_UPDATE false item *item_get(const char *key, const size_t nkey, LIBEVENT_THREAD *t, const bool do_update); item *item_get_locked(const char *key, const size_t nkey, LIBEVENT_THREAD *t, const bool do_update, uint32_t *hv); item *item_touch(const char *key, const size_t nkey, uint32_t exptime, LIBEVENT_THREAD *t); int item_link(item *it); void item_remove(item *it); int item_replace(item *it, item *new_it, const uint32_t hv); void item_unlink(item *it); void item_lock(uint32_t hv); void *item_trylock(uint32_t hv); void item_trylock_unlock(void *arg); void item_unlock(uint32_t hv); void pause_threads(enum pause_thread_types type); void stop_threads(void); int stop_conn_timeout_thread(void); #define refcount_incr(it) ++(it->refcount) #define refcount_decr(it) --(it->refcount) void STATS_LOCK(void); void STATS_UNLOCK(void); #define THR_STATS_LOCK(t) pthread_mutex_lock(&t->stats.mutex) #define THR_STATS_UNLOCK(t) pthread_mutex_unlock(&t->stats.mutex) void threadlocal_stats_reset(void); void threadlocal_stats_aggregate(struct thread_stats *stats); void slab_stats_aggregate(struct thread_stats *stats, struct slab_stats *out); void thread_setname(pthread_t thread, const char *name); LIBEVENT_THREAD *get_worker_thread(int id); /* Stat processing functions */ void append_stat(const char *name, ADD_STAT add_stats, conn *c, const char *fmt, ...); enum store_item_type store_item(item *item, int comm, LIBEVENT_THREAD *t, int *nbytes, uint64_t *cas, bool cas_stale); /* Protocol related code */ void out_string(conn *c, const char *str); #define REALTIME_MAXDELTA 60*60*24*30 /* Negative exptimes can underflow and end up immortal. realtime() will immediately expire values that are greater than REALTIME_MAXDELTA, but less than process_started, so lets aim for that. */ #define EXPTIME_TO_POSITIVE_TIME(exptime) (exptime < 0) ? \ REALTIME_MAXDELTA + 1 : exptime rel_time_t realtime(const time_t exptime); item* limited_get(const char *key, size_t nkey, LIBEVENT_THREAD *t, uint32_t exptime, bool should_touch, bool do_update, bool *overflow); item* limited_get_locked(const char *key, size_t nkey, LIBEVENT_THREAD *t, bool do_update, uint32_t *hv, bool *overflow); // Read/Response object handlers. void resp_reset(mc_resp *resp); void resp_add_iov(mc_resp *resp, const void *buf, int len); void resp_add_chunked_iov(mc_resp *resp, const void *buf, int len); bool resp_start(conn *c); mc_resp *resp_start_unlinked(conn *c); mc_resp* resp_finish(conn *c, mc_resp *resp); void resp_free(LIBEVENT_THREAD *th, mc_resp *resp); bool resp_has_stack(conn *c); bool rbuf_switch_to_malloc(conn *c); void conn_release_items(conn *c); void conn_set_state(conn *c, enum conn_states state); void out_of_memory(conn *c, char *ascii_error); void out_errstring(conn *c, const char *str); void write_and_free(conn *c, char *buf, int bytes); void server_stats(ADD_STAT add_stats, conn *c); void append_stats(const char *key, const uint16_t klen, const char *val, const uint32_t vlen, const void *cookie); /** Return a datum for stats in binary protocol */ bool get_stats(const char *stat_type, int nkey, ADD_STAT add_stats, void *c); void stats_reset(void); void process_stat_settings(ADD_STAT add_stats, void *c); void process_stats_conns(ADD_STAT add_stats, void *c); #if HAVE_DROP_PRIVILEGES extern void setup_privilege_violations_handler(void); extern void drop_privileges(void); #else #define setup_privilege_violations_handler() #define drop_privileges() #endif #if HAVE_DROP_WORKER_PRIVILEGES extern void drop_worker_privileges(void); #else #define drop_worker_privileges() #endif /* If supported, give compiler hints for branch prediction. */ #if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96) #define __builtin_expect(x, expected_value) (x) #endif #define likely(x) __builtin_expect((x),1) #define unlikely(x) __builtin_expect((x),0) memcached-1.6.20/COPYING0000644000175000017500000000273711246331452011474 00000000000000Copyright (c) 2003, Danga Interactive, Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the Danga Interactive nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. memcached-1.6.20/Makefile.in0000664000175000017500000074021514427544303012515 00000000000000# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. @SET_MAKE@ VPATH = @srcdir@ am__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) pkgdatadir = $(datadir)/@PACKAGE@ pkgincludedir = $(includedir)/@PACKAGE@ pkglibdir = $(libdir)/@PACKAGE@ pkglibexecdir = $(libexecdir)/@PACKAGE@ am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd install_sh_DATA = $(install_sh) -c -m 644 install_sh_PROGRAM = $(install_sh) -c install_sh_SCRIPT = $(install_sh) -c INSTALL_HEADER = $(INSTALL_DATA) transform = $(program_transform_name) NORMAL_INSTALL = : PRE_INSTALL = : POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : build_triplet = @build@ host_triplet = @host@ bin_PROGRAMS = memcached$(EXEEXT) noinst_PROGRAMS = memcached-debug$(EXEEXT) sizes$(EXEEXT) \ testapp$(EXEEXT) timedrun$(EXEEXT) @BUILD_SOLARIS_PRIVS_TRUE@am__append_1 = solaris_priv.c @BUILD_LINUX_PRIVS_TRUE@am__append_2 = linux_priv.c @BUILD_OPENBSD_PRIVS_TRUE@am__append_3 = openbsd_priv.c @BUILD_FREEBSD_PRIVS_TRUE@am__append_4 = freebsd_priv.c @BUILD_DARWIN_PRIVS_TRUE@am__append_5 = darwin_priv.c @ENABLE_SASL_TRUE@am__append_6 = sasl_defs.c @ENABLE_PROXY_TRUE@am__append_7 = proto_proxy.c proto_proxy.h vendor/mcmc/mcmc.h \ @ENABLE_PROXY_TRUE@ proxy_xxhash.c proxy.h \ @ENABLE_PROXY_TRUE@ proxy_await.c proxy_ustats.c \ @ENABLE_PROXY_TRUE@ proxy_jump_hash.c proxy_request.c \ @ENABLE_PROXY_TRUE@ proxy_network.c proxy_lua.c \ @ENABLE_PROXY_TRUE@ proxy_config.c proxy_ring_hash.c \ @ENABLE_PROXY_TRUE@ proxy_internal.c \ @ENABLE_PROXY_TRUE@ md5.c md5.h @ENABLE_EXTSTORE_TRUE@am__append_8 = extstore.c extstore.h \ @ENABLE_EXTSTORE_TRUE@ crc32c.c crc32c.h \ @ENABLE_EXTSTORE_TRUE@ storage.c storage.h \ @ENABLE_EXTSTORE_TRUE@ slab_automove_extstore.c slab_automove_extstore.h @ENABLE_TLS_TRUE@am__append_9 = tls.c tls.h @BUILD_LINUX_PRIVS_TRUE@am__append_10 = -lseccomp @BUILD_LINUX_PRIVS_TRUE@am__append_11 = -lseccomp @BUILD_DTRACE_TRUE@am__append_12 = memcached_dtrace.h @BUILD_DTRACE_TRUE@am__append_13 = memcached_dtrace.h @DTRACE_INSTRUMENT_OBJ_TRUE@am__append_14 = memcached_dtrace.o @DTRACE_INSTRUMENT_OBJ_TRUE@am__append_15 = memcached_dtrace.o @DTRACE_INSTRUMENT_OBJ_TRUE@am__append_16 = memcached_debug_dtrace.o @DTRACE_INSTRUMENT_OBJ_TRUE@am__append_17 = memcached_debug_dtrace.o @DTRACE_INSTRUMENT_OBJ_TRUE@am__append_18 = memcached_dtrace.o memcached_debug_dtrace.o @ENABLE_PROXY_TRUE@am__append_19 = vendor/lua/src/liblua.a vendor/mcmc/mcmc.o @ENABLE_PROXY_TRUE@am__append_20 = vendor/lua/src/liblua.a vendor/mcmc/mcmc.o @ENABLE_PROXY_URING_TRUE@am__append_21 = vendor/liburing/src/liburing.a @ENABLE_PROXY_URING_TRUE@am__append_22 = vendor/liburing/src/liburing.a @ENABLE_PROXY_TRUE@am__append_23 = vendor subdir = . ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/version.m4 \ $(top_srcdir)/m4/c99-backport.m4 $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \ $(am__configure_deps) $(pkginclude_HEADERS) $(am__DIST_COMMON) am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ configure.lineno config.status.lineno mkinstalldirs = $(install_sh) -d CONFIG_HEADER = config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(pkgincludedir)" PROGRAMS = $(bin_PROGRAMS) $(noinst_PROGRAMS) am__memcached_SOURCES_DIST = memcached.c memcached.h hash.c hash.h \ jenkins_hash.c jenkins_hash.h murmur3_hash.c murmur3_hash.h \ queue.h slabs.c slabs.h items.c items.h assoc.c assoc.h \ thread.c daemon.c stats_prefix.c stats_prefix.h util.c util.h \ trace.h cache.c cache.h sasl_defs.h bipbuffer.c bipbuffer.h \ base64.c base64.h logger.c logger.h crawler.c crawler.h \ itoa_ljust.c itoa_ljust.h slab_automove.c slab_automove.h \ authfile.c authfile.h restart.c restart.h proto_text.c \ proto_text.h proto_bin.c proto_bin.h solaris_priv.c \ linux_priv.c openbsd_priv.c freebsd_priv.c darwin_priv.c \ sasl_defs.c proto_proxy.c proto_proxy.h vendor/mcmc/mcmc.h \ proxy_xxhash.c proxy.h proxy_await.c proxy_ustats.c \ proxy_jump_hash.c proxy_request.c proxy_network.c proxy_lua.c \ proxy_config.c proxy_ring_hash.c proxy_internal.c md5.c md5.h \ extstore.c extstore.h crc32c.c crc32c.h storage.c storage.h \ slab_automove_extstore.c slab_automove_extstore.h tls.c tls.h @BUILD_SOLARIS_PRIVS_TRUE@am__objects_1 = \ @BUILD_SOLARIS_PRIVS_TRUE@ memcached-solaris_priv.$(OBJEXT) @BUILD_LINUX_PRIVS_TRUE@am__objects_2 = \ @BUILD_LINUX_PRIVS_TRUE@ memcached-linux_priv.$(OBJEXT) @BUILD_OPENBSD_PRIVS_TRUE@am__objects_3 = \ @BUILD_OPENBSD_PRIVS_TRUE@ memcached-openbsd_priv.$(OBJEXT) @BUILD_FREEBSD_PRIVS_TRUE@am__objects_4 = \ @BUILD_FREEBSD_PRIVS_TRUE@ memcached-freebsd_priv.$(OBJEXT) @BUILD_DARWIN_PRIVS_TRUE@am__objects_5 = \ @BUILD_DARWIN_PRIVS_TRUE@ memcached-darwin_priv.$(OBJEXT) @ENABLE_SASL_TRUE@am__objects_6 = memcached-sasl_defs.$(OBJEXT) @ENABLE_PROXY_TRUE@am__objects_7 = memcached-proto_proxy.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached-proxy_xxhash.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached-proxy_await.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached-proxy_ustats.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached-proxy_jump_hash.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached-proxy_request.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached-proxy_network.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached-proxy_lua.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached-proxy_config.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached-proxy_ring_hash.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached-proxy_internal.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached-md5.$(OBJEXT) @ENABLE_EXTSTORE_TRUE@am__objects_8 = memcached-extstore.$(OBJEXT) \ @ENABLE_EXTSTORE_TRUE@ memcached-crc32c.$(OBJEXT) \ @ENABLE_EXTSTORE_TRUE@ memcached-storage.$(OBJEXT) \ @ENABLE_EXTSTORE_TRUE@ memcached-slab_automove_extstore.$(OBJEXT) @ENABLE_TLS_TRUE@am__objects_9 = memcached-tls.$(OBJEXT) am_memcached_OBJECTS = memcached-memcached.$(OBJEXT) \ memcached-hash.$(OBJEXT) memcached-jenkins_hash.$(OBJEXT) \ memcached-murmur3_hash.$(OBJEXT) memcached-slabs.$(OBJEXT) \ memcached-items.$(OBJEXT) memcached-assoc.$(OBJEXT) \ memcached-thread.$(OBJEXT) memcached-daemon.$(OBJEXT) \ memcached-stats_prefix.$(OBJEXT) memcached-util.$(OBJEXT) \ memcached-cache.$(OBJEXT) memcached-bipbuffer.$(OBJEXT) \ memcached-base64.$(OBJEXT) memcached-logger.$(OBJEXT) \ memcached-crawler.$(OBJEXT) memcached-itoa_ljust.$(OBJEXT) \ memcached-slab_automove.$(OBJEXT) memcached-authfile.$(OBJEXT) \ memcached-restart.$(OBJEXT) memcached-proto_text.$(OBJEXT) \ memcached-proto_bin.$(OBJEXT) $(am__objects_1) \ $(am__objects_2) $(am__objects_3) $(am__objects_4) \ $(am__objects_5) $(am__objects_6) $(am__objects_7) \ $(am__objects_8) $(am__objects_9) memcached_OBJECTS = $(am_memcached_OBJECTS) am__DEPENDENCIES_1 = am__memcached_debug_SOURCES_DIST = memcached.c memcached.h hash.c \ hash.h jenkins_hash.c jenkins_hash.h murmur3_hash.c \ murmur3_hash.h queue.h slabs.c slabs.h items.c items.h assoc.c \ assoc.h thread.c daemon.c stats_prefix.c stats_prefix.h util.c \ util.h trace.h cache.c cache.h sasl_defs.h bipbuffer.c \ bipbuffer.h base64.c base64.h logger.c logger.h crawler.c \ crawler.h itoa_ljust.c itoa_ljust.h slab_automove.c \ slab_automove.h authfile.c authfile.h restart.c restart.h \ proto_text.c proto_text.h proto_bin.c proto_bin.h \ solaris_priv.c linux_priv.c openbsd_priv.c freebsd_priv.c \ darwin_priv.c sasl_defs.c proto_proxy.c proto_proxy.h \ vendor/mcmc/mcmc.h proxy_xxhash.c proxy.h proxy_await.c \ proxy_ustats.c proxy_jump_hash.c proxy_request.c \ proxy_network.c proxy_lua.c proxy_config.c proxy_ring_hash.c \ proxy_internal.c md5.c md5.h extstore.c extstore.h crc32c.c \ crc32c.h storage.c storage.h slab_automove_extstore.c \ slab_automove_extstore.h tls.c tls.h @BUILD_SOLARIS_PRIVS_TRUE@am__objects_10 = memcached_debug-solaris_priv.$(OBJEXT) @BUILD_LINUX_PRIVS_TRUE@am__objects_11 = \ @BUILD_LINUX_PRIVS_TRUE@ memcached_debug-linux_priv.$(OBJEXT) @BUILD_OPENBSD_PRIVS_TRUE@am__objects_12 = memcached_debug-openbsd_priv.$(OBJEXT) @BUILD_FREEBSD_PRIVS_TRUE@am__objects_13 = memcached_debug-freebsd_priv.$(OBJEXT) @BUILD_DARWIN_PRIVS_TRUE@am__objects_14 = memcached_debug-darwin_priv.$(OBJEXT) @ENABLE_SASL_TRUE@am__objects_15 = \ @ENABLE_SASL_TRUE@ memcached_debug-sasl_defs.$(OBJEXT) @ENABLE_PROXY_TRUE@am__objects_16 = \ @ENABLE_PROXY_TRUE@ memcached_debug-proto_proxy.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached_debug-proxy_xxhash.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached_debug-proxy_await.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached_debug-proxy_ustats.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached_debug-proxy_jump_hash.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached_debug-proxy_request.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached_debug-proxy_network.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached_debug-proxy_lua.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached_debug-proxy_config.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached_debug-proxy_ring_hash.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached_debug-proxy_internal.$(OBJEXT) \ @ENABLE_PROXY_TRUE@ memcached_debug-md5.$(OBJEXT) @ENABLE_EXTSTORE_TRUE@am__objects_17 = \ @ENABLE_EXTSTORE_TRUE@ memcached_debug-extstore.$(OBJEXT) \ @ENABLE_EXTSTORE_TRUE@ memcached_debug-crc32c.$(OBJEXT) \ @ENABLE_EXTSTORE_TRUE@ memcached_debug-storage.$(OBJEXT) \ @ENABLE_EXTSTORE_TRUE@ memcached_debug-slab_automove_extstore.$(OBJEXT) @ENABLE_TLS_TRUE@am__objects_18 = memcached_debug-tls.$(OBJEXT) am__objects_19 = memcached_debug-memcached.$(OBJEXT) \ memcached_debug-hash.$(OBJEXT) \ memcached_debug-jenkins_hash.$(OBJEXT) \ memcached_debug-murmur3_hash.$(OBJEXT) \ memcached_debug-slabs.$(OBJEXT) \ memcached_debug-items.$(OBJEXT) \ memcached_debug-assoc.$(OBJEXT) \ memcached_debug-thread.$(OBJEXT) \ memcached_debug-daemon.$(OBJEXT) \ memcached_debug-stats_prefix.$(OBJEXT) \ memcached_debug-util.$(OBJEXT) memcached_debug-cache.$(OBJEXT) \ memcached_debug-bipbuffer.$(OBJEXT) \ memcached_debug-base64.$(OBJEXT) \ memcached_debug-logger.$(OBJEXT) \ memcached_debug-crawler.$(OBJEXT) \ memcached_debug-itoa_ljust.$(OBJEXT) \ memcached_debug-slab_automove.$(OBJEXT) \ memcached_debug-authfile.$(OBJEXT) \ memcached_debug-restart.$(OBJEXT) \ memcached_debug-proto_text.$(OBJEXT) \ memcached_debug-proto_bin.$(OBJEXT) $(am__objects_10) \ $(am__objects_11) $(am__objects_12) $(am__objects_13) \ $(am__objects_14) $(am__objects_15) $(am__objects_16) \ $(am__objects_17) $(am__objects_18) am_memcached_debug_OBJECTS = $(am__objects_19) memcached_debug_OBJECTS = $(am_memcached_debug_OBJECTS) memcached_debug_LINK = $(CCLD) $(memcached_debug_CFLAGS) $(CFLAGS) \ $(AM_LDFLAGS) $(LDFLAGS) -o $@ sizes_SOURCES = sizes.c sizes_OBJECTS = sizes.$(OBJEXT) sizes_LDADD = $(LDADD) am_testapp_OBJECTS = testapp.$(OBJEXT) util.$(OBJEXT) \ stats_prefix.$(OBJEXT) jenkins_hash.$(OBJEXT) \ murmur3_hash.$(OBJEXT) cache.$(OBJEXT) crc32c.$(OBJEXT) testapp_OBJECTS = $(am_testapp_OBJECTS) testapp_LDADD = $(LDADD) am_timedrun_OBJECTS = timedrun.$(OBJEXT) timedrun_OBJECTS = $(am_timedrun_OBJECTS) timedrun_LDADD = $(LDADD) AM_V_P = $(am__v_P_@AM_V@) am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) am__v_P_0 = false am__v_P_1 = : AM_V_GEN = $(am__v_GEN_@AM_V@) am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) am__v_GEN_0 = @echo " GEN " $@; am__v_GEN_1 = AM_V_at = $(am__v_at_@AM_V@) am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) am__v_at_0 = @ am__v_at_1 = DEFAULT_INCLUDES = -I.@am__isrc@ depcomp = $(SHELL) $(top_srcdir)/depcomp am__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/cache.Po ./$(DEPDIR)/crc32c.Po \ ./$(DEPDIR)/jenkins_hash.Po ./$(DEPDIR)/memcached-assoc.Po \ ./$(DEPDIR)/memcached-authfile.Po \ ./$(DEPDIR)/memcached-base64.Po \ ./$(DEPDIR)/memcached-bipbuffer.Po \ ./$(DEPDIR)/memcached-cache.Po \ ./$(DEPDIR)/memcached-crawler.Po \ ./$(DEPDIR)/memcached-crc32c.Po \ ./$(DEPDIR)/memcached-daemon.Po \ ./$(DEPDIR)/memcached-darwin_priv.Po \ ./$(DEPDIR)/memcached-extstore.Po \ ./$(DEPDIR)/memcached-freebsd_priv.Po \ ./$(DEPDIR)/memcached-hash.Po ./$(DEPDIR)/memcached-items.Po \ ./$(DEPDIR)/memcached-itoa_ljust.Po \ ./$(DEPDIR)/memcached-jenkins_hash.Po \ ./$(DEPDIR)/memcached-linux_priv.Po \ ./$(DEPDIR)/memcached-logger.Po ./$(DEPDIR)/memcached-md5.Po \ ./$(DEPDIR)/memcached-memcached.Po \ ./$(DEPDIR)/memcached-murmur3_hash.Po \ ./$(DEPDIR)/memcached-openbsd_priv.Po \ ./$(DEPDIR)/memcached-proto_bin.Po \ ./$(DEPDIR)/memcached-proto_proxy.Po \ ./$(DEPDIR)/memcached-proto_text.Po \ ./$(DEPDIR)/memcached-proxy_await.Po \ ./$(DEPDIR)/memcached-proxy_config.Po \ ./$(DEPDIR)/memcached-proxy_internal.Po \ ./$(DEPDIR)/memcached-proxy_jump_hash.Po \ ./$(DEPDIR)/memcached-proxy_lua.Po \ ./$(DEPDIR)/memcached-proxy_network.Po \ ./$(DEPDIR)/memcached-proxy_request.Po \ ./$(DEPDIR)/memcached-proxy_ring_hash.Po \ ./$(DEPDIR)/memcached-proxy_ustats.Po \ ./$(DEPDIR)/memcached-proxy_xxhash.Po \ ./$(DEPDIR)/memcached-restart.Po \ ./$(DEPDIR)/memcached-sasl_defs.Po \ ./$(DEPDIR)/memcached-slab_automove.Po \ ./$(DEPDIR)/memcached-slab_automove_extstore.Po \ ./$(DEPDIR)/memcached-slabs.Po \ ./$(DEPDIR)/memcached-solaris_priv.Po \ ./$(DEPDIR)/memcached-stats_prefix.Po \ ./$(DEPDIR)/memcached-storage.Po \ ./$(DEPDIR)/memcached-thread.Po ./$(DEPDIR)/memcached-tls.Po \ ./$(DEPDIR)/memcached-util.Po \ ./$(DEPDIR)/memcached_debug-assoc.Po \ ./$(DEPDIR)/memcached_debug-authfile.Po \ ./$(DEPDIR)/memcached_debug-base64.Po \ ./$(DEPDIR)/memcached_debug-bipbuffer.Po \ ./$(DEPDIR)/memcached_debug-cache.Po \ ./$(DEPDIR)/memcached_debug-crawler.Po \ ./$(DEPDIR)/memcached_debug-crc32c.Po \ ./$(DEPDIR)/memcached_debug-daemon.Po \ ./$(DEPDIR)/memcached_debug-darwin_priv.Po \ ./$(DEPDIR)/memcached_debug-extstore.Po \ ./$(DEPDIR)/memcached_debug-freebsd_priv.Po \ ./$(DEPDIR)/memcached_debug-hash.Po \ ./$(DEPDIR)/memcached_debug-items.Po \ ./$(DEPDIR)/memcached_debug-itoa_ljust.Po \ ./$(DEPDIR)/memcached_debug-jenkins_hash.Po \ ./$(DEPDIR)/memcached_debug-linux_priv.Po \ ./$(DEPDIR)/memcached_debug-logger.Po \ ./$(DEPDIR)/memcached_debug-md5.Po \ ./$(DEPDIR)/memcached_debug-memcached.Po \ ./$(DEPDIR)/memcached_debug-murmur3_hash.Po \ ./$(DEPDIR)/memcached_debug-openbsd_priv.Po \ ./$(DEPDIR)/memcached_debug-proto_bin.Po \ ./$(DEPDIR)/memcached_debug-proto_proxy.Po \ ./$(DEPDIR)/memcached_debug-proto_text.Po \ ./$(DEPDIR)/memcached_debug-proxy_await.Po \ ./$(DEPDIR)/memcached_debug-proxy_config.Po \ ./$(DEPDIR)/memcached_debug-proxy_internal.Po \ ./$(DEPDIR)/memcached_debug-proxy_jump_hash.Po \ ./$(DEPDIR)/memcached_debug-proxy_lua.Po \ ./$(DEPDIR)/memcached_debug-proxy_network.Po \ ./$(DEPDIR)/memcached_debug-proxy_request.Po \ ./$(DEPDIR)/memcached_debug-proxy_ring_hash.Po \ ./$(DEPDIR)/memcached_debug-proxy_ustats.Po \ ./$(DEPDIR)/memcached_debug-proxy_xxhash.Po \ ./$(DEPDIR)/memcached_debug-restart.Po \ ./$(DEPDIR)/memcached_debug-sasl_defs.Po \ ./$(DEPDIR)/memcached_debug-slab_automove.Po \ ./$(DEPDIR)/memcached_debug-slab_automove_extstore.Po \ ./$(DEPDIR)/memcached_debug-slabs.Po \ ./$(DEPDIR)/memcached_debug-solaris_priv.Po \ ./$(DEPDIR)/memcached_debug-stats_prefix.Po \ ./$(DEPDIR)/memcached_debug-storage.Po \ ./$(DEPDIR)/memcached_debug-thread.Po \ ./$(DEPDIR)/memcached_debug-tls.Po \ ./$(DEPDIR)/memcached_debug-util.Po \ ./$(DEPDIR)/murmur3_hash.Po ./$(DEPDIR)/sizes.Po \ ./$(DEPDIR)/stats_prefix.Po ./$(DEPDIR)/testapp.Po \ ./$(DEPDIR)/timedrun.Po ./$(DEPDIR)/util.Po am__mv = mv -f AM_V_lt = $(am__v_lt_@AM_V@) am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) am__v_lt_0 = --silent am__v_lt_1 = COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) AM_V_CC = $(am__v_CC_@AM_V@) am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) am__v_CC_0 = @echo " CC " $@; am__v_CC_1 = CCLD = $(CC) LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ AM_V_CCLD = $(am__v_CCLD_@AM_V@) am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) am__v_CCLD_0 = @echo " CCLD " $@; am__v_CCLD_1 = SOURCES = $(memcached_SOURCES) $(memcached_debug_SOURCES) sizes.c \ $(testapp_SOURCES) $(timedrun_SOURCES) DIST_SOURCES = $(am__memcached_SOURCES_DIST) \ $(am__memcached_debug_SOURCES_DIST) sizes.c $(testapp_SOURCES) \ $(timedrun_SOURCES) RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ ctags-recursive dvi-recursive html-recursive info-recursive \ install-data-recursive install-dvi-recursive \ install-exec-recursive install-html-recursive \ install-info-recursive install-pdf-recursive \ install-ps-recursive install-recursive installcheck-recursive \ installdirs-recursive pdf-recursive ps-recursive \ tags-recursive uninstall-recursive am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; am__vpath_adj = case $$p in \ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ *) f=$$p;; \ esac; am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; am__install_max = 40 am__nobase_strip_setup = \ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` am__nobase_strip = \ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" am__nobase_list = $(am__nobase_strip_setup); \ for p in $$list; do echo "$$p $$p"; done | \ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ if (++n[$$2] == $(am__install_max)) \ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ END { for (dir in files) print dir, files[dir] }' am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' am__uninstall_files_from_dir = { \ test -z "$$files" \ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ $(am__cd) "$$dir" && rm -f $$files; }; \ } HEADERS = $(pkginclude_HEADERS) RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ distclean-recursive maintainer-clean-recursive am__recursive_targets = \ $(RECURSIVE_TARGETS) \ $(RECURSIVE_CLEAN_TARGETS) \ $(am__extra_recursive_targets) AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ cscope distdir distdir-am dist dist-all distcheck am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) \ config.h.in # Read a list of newline-separated strings from the standard input, # and print each of them once, without duplicates. Input order is # *not* preserved. am__uniquify_input = $(AWK) '\ BEGIN { nonempty = 0; } \ { items[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in items) print i; }; } \ ' # Make sure the list of sources is unique. This is necessary because, # e.g., the same source file might be shared among _SOURCES variables # for different programs/libraries. am__define_uniq_tagged_files = \ list='$(am__tagged_files)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | $(am__uniquify_input)` DIST_SUBDIRS = doc vendor am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/config.h.in AUTHORS \ COPYING ChangeLog NEWS README.md compile config.guess \ config.sub depcomp install-sh missing DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) distdir = $(PACKAGE)-$(VERSION) top_distdir = $(distdir) am__remove_distdir = \ if test -d "$(distdir)"; then \ find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \ && rm -rf "$(distdir)" \ || { sleep 5 && rm -rf "$(distdir)"; }; \ else :; fi am__post_remove_distdir = $(am__remove_distdir) am__relativize = \ dir0=`pwd`; \ sed_first='s,^\([^/]*\)/.*$$,\1,'; \ sed_rest='s,^[^/]*/*,,'; \ sed_last='s,^.*/\([^/]*\)$$,\1,'; \ sed_butlast='s,/*[^/]*$$,,'; \ while test -n "$$dir1"; do \ first=`echo "$$dir1" | sed -e "$$sed_first"`; \ if test "$$first" != "."; then \ if test "$$first" = ".."; then \ dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ else \ first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ if test "$$first2" = "$$first"; then \ dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ else \ dir2="../$$dir2"; \ fi; \ dir0="$$dir0"/"$$first"; \ fi; \ fi; \ dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ done; \ reldir="$$dir2" DIST_ARCHIVES = $(distdir).tar.gz GZIP_ENV = --best DIST_TARGETS = dist-gzip # Exists only to be overridden by the user if desired. AM_DISTCHECK_DVI_TARGET = dvi distuninstallcheck_listfiles = find . -type f -print am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \ | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$' distcleancheck_listfiles = find . -type f -print ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ CC = @CC@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ CYGPATH_W = @CYGPATH_W@ DEFS = @DEFS@ DEPDIR = @DEPDIR@ DTRACE = @DTRACE@ DTRACEFLAGS = @DTRACEFLAGS@ ECHO_C = @ECHO_C@ ECHO_N = @ECHO_N@ ECHO_T = @ECHO_T@ EGREP = @EGREP@ ENABLE_SASL = @ENABLE_SASL@ ETAGS = @ETAGS@ EXEEXT = @EXEEXT@ GREP = @GREP@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ LDFLAGS = @LDFLAGS@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ LTLIBOBJS = @LTLIBOBJS@ MAKEINFO = @MAKEINFO@ MKDIR_P = @MKDIR_P@ OBJEXT = @OBJEXT@ OPENSSL_CFLAGS = @OPENSSL_CFLAGS@ OPENSSL_LIBS = @OPENSSL_LIBS@ PACKAGE = @PACKAGE@ PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ PKG_CONFIG = @PKG_CONFIG@ PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ PROFILER = @PROFILER@ PROFILER_FLAGS = @PROFILER_FLAGS@ PROFILER_LDFLAGS = @PROFILER_LDFLAGS@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ VERSION = @VERSION@ XML2RFC = @XML2RFC@ XSLTPROC = @XSLTPROC@ abs_builddir = @abs_builddir@ abs_srcdir = @abs_srcdir@ abs_top_builddir = @abs_top_builddir@ abs_top_srcdir = @abs_top_srcdir@ ac_ct_CC = @ac_ct_CC@ am__include = @am__include@ am__leading_dot = @am__leading_dot@ am__quote = @am__quote@ am__tar = @am__tar@ am__untar = @am__untar@ bindir = @bindir@ build = @build@ build_alias = @build_alias@ build_cpu = @build_cpu@ build_os = @build_os@ build_vendor = @build_vendor@ builddir = @builddir@ datadir = @datadir@ datarootdir = @datarootdir@ docdir = @docdir@ dvidir = @dvidir@ exec_prefix = @exec_prefix@ host = @host@ host_alias = @host_alias@ host_cpu = @host_cpu@ host_os = @host_os@ host_vendor = @host_vendor@ htmldir = @htmldir@ includedir = @includedir@ infodir = @infodir@ install_sh = @install_sh@ libdir = @libdir@ libexecdir = @libexecdir@ localedir = @localedir@ localstatedir = @localstatedir@ mandir = @mandir@ mkdir_p = @mkdir_p@ oldincludedir = @oldincludedir@ pdfdir = @pdfdir@ prefix = @prefix@ program_transform_name = @program_transform_name@ psdir = @psdir@ runstatedir = @runstatedir@ sbindir = @sbindir@ sharedstatedir = @sharedstatedir@ srcdir = @srcdir@ sysconfdir = @sysconfdir@ target_alias = @target_alias@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ pkginclude_HEADERS = protocol_binary.h xxhash.h BUILT_SOURCES = $(am__append_12) testapp_SOURCES = testapp.c util.c util.h stats_prefix.c stats_prefix.h jenkins_hash.c murmur3_hash.c hash.h cache.c crc32c.c timedrun_SOURCES = timedrun.c memcached_SOURCES = memcached.c memcached.h hash.c hash.h \ jenkins_hash.c jenkins_hash.h murmur3_hash.c murmur3_hash.h \ queue.h slabs.c slabs.h items.c items.h assoc.c assoc.h \ thread.c daemon.c stats_prefix.c stats_prefix.h util.c util.h \ trace.h cache.c cache.h sasl_defs.h bipbuffer.c bipbuffer.h \ base64.c base64.h logger.c logger.h crawler.c crawler.h \ itoa_ljust.c itoa_ljust.h slab_automove.c slab_automove.h \ authfile.c authfile.h restart.c restart.h proto_text.c \ proto_text.h proto_bin.c proto_bin.h $(am__append_1) \ $(am__append_2) $(am__append_3) $(am__append_4) \ $(am__append_5) $(am__append_6) $(am__append_7) \ $(am__append_8) $(am__append_9) memcached_debug_SOURCES = $(memcached_SOURCES) memcached_CPPFLAGS = -DNDEBUG memcached_debug_LDADD = @PROFILER_LDFLAGS@ $(am__append_11) \ $(am__append_16) $(am__append_20) $(am__append_22) memcached_debug_CFLAGS = @PROFILER_FLAGS@ -DMEMCACHED_DEBUG memcached_LDADD = $(am__append_10) $(am__append_14) $(am__append_19) \ $(am__append_21) memcached_DEPENDENCIES = $(am__append_15) memcached_debug_DEPENDENCIES = $(am__append_17) CLEANFILES = $(am__append_13) $(am__append_18) SUBDIRS = doc $(am__append_23) DIST_DIRS = scripts EXTRA_DIST = doc scripts t memcached.spec memcached_dtrace.d \ version.m4 README.md LICENSE.bipbuffer vendor/Makefile \ vendor/lua vendor/mcmc MOSTLYCLEANFILES = *.gcov *.gcno *.gcda *.tcov all: $(BUILT_SOURCES) config.h $(MAKE) $(AM_MAKEFLAGS) all-recursive .SUFFIXES: .SUFFIXES: .c .o .obj am--refresh: Makefile @: $(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \ $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \ && exit 0; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ echo ' $(SHELL) ./config.status'; \ $(SHELL) ./config.status;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) $(SHELL) ./config.status --recheck $(top_srcdir)/configure: $(am__configure_deps) $(am__cd) $(srcdir) && $(AUTOCONF) $(ACLOCAL_M4): $(am__aclocal_m4_deps) $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) $(am__aclocal_m4_deps): config.h: stamp-h1 @test -f $@ || rm -f stamp-h1 @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1 stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status @rm -f stamp-h1 cd $(top_builddir) && $(SHELL) ./config.status config.h $(srcdir)/config.h.in: $(am__configure_deps) ($(am__cd) $(top_srcdir) && $(AUTOHEADER)) rm -f stamp-h1 touch $@ distclean-hdr: -rm -f config.h stamp-h1 install-binPROGRAMS: $(bin_PROGRAMS) @$(NORMAL_INSTALL) @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \ $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \ fi; \ for p in $$list; do echo "$$p $$p"; done | \ sed 's/$(EXEEXT)$$//' | \ while read p p1; do if test -f $$p \ ; then echo "$$p"; echo "$$p"; else :; fi; \ done | \ sed -e 'p;s,.*/,,;n;h' \ -e 's|.*|.|' \ -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \ sed 'N;N;N;s,\n, ,g' | \ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ if ($$2 == $$4) files[d] = files[d] " " $$1; \ else { print "f", $$3 "/" $$4, $$1; } } \ END { for (d in files) print "f", d, files[d] }' | \ while read type dir files; do \ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ test -z "$$files" || { \ echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \ $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \ } \ ; done uninstall-binPROGRAMS: @$(NORMAL_UNINSTALL) @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ files=`for p in $$list; do echo "$$p"; done | \ sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \ -e 's/$$/$(EXEEXT)/' \ `; \ test -n "$$list" || exit 0; \ echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \ cd "$(DESTDIR)$(bindir)" && rm -f $$files clean-binPROGRAMS: -test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS) clean-noinstPROGRAMS: -test -z "$(noinst_PROGRAMS)" || rm -f $(noinst_PROGRAMS) memcached$(EXEEXT): $(memcached_OBJECTS) $(memcached_DEPENDENCIES) $(EXTRA_memcached_DEPENDENCIES) @rm -f memcached$(EXEEXT) $(AM_V_CCLD)$(LINK) $(memcached_OBJECTS) $(memcached_LDADD) $(LIBS) memcached-debug$(EXEEXT): $(memcached_debug_OBJECTS) $(memcached_debug_DEPENDENCIES) $(EXTRA_memcached_debug_DEPENDENCIES) @rm -f memcached-debug$(EXEEXT) $(AM_V_CCLD)$(memcached_debug_LINK) $(memcached_debug_OBJECTS) $(memcached_debug_LDADD) $(LIBS) sizes$(EXEEXT): $(sizes_OBJECTS) $(sizes_DEPENDENCIES) $(EXTRA_sizes_DEPENDENCIES) @rm -f sizes$(EXEEXT) $(AM_V_CCLD)$(LINK) $(sizes_OBJECTS) $(sizes_LDADD) $(LIBS) testapp$(EXEEXT): $(testapp_OBJECTS) $(testapp_DEPENDENCIES) $(EXTRA_testapp_DEPENDENCIES) @rm -f testapp$(EXEEXT) $(AM_V_CCLD)$(LINK) $(testapp_OBJECTS) $(testapp_LDADD) $(LIBS) timedrun$(EXEEXT): $(timedrun_OBJECTS) $(timedrun_DEPENDENCIES) $(EXTRA_timedrun_DEPENDENCIES) @rm -f timedrun$(EXEEXT) $(AM_V_CCLD)$(LINK) $(timedrun_OBJECTS) $(timedrun_LDADD) $(LIBS) mostlyclean-compile: -rm -f *.$(OBJEXT) distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cache.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/crc32c.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jenkins_hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-assoc.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-authfile.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-base64.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-bipbuffer.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-cache.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-crawler.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-crc32c.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-daemon.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-darwin_priv.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-extstore.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-freebsd_priv.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-items.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-itoa_ljust.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-jenkins_hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-linux_priv.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-logger.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-md5.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-memcached.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-murmur3_hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-openbsd_priv.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proto_bin.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proto_proxy.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proto_text.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proxy_await.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proxy_config.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proxy_internal.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proxy_jump_hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proxy_lua.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proxy_network.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proxy_request.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proxy_ring_hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proxy_ustats.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-proxy_xxhash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-restart.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-sasl_defs.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-slab_automove.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-slab_automove_extstore.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-slabs.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-solaris_priv.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-stats_prefix.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-storage.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-thread.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-tls.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached-util.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-assoc.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-authfile.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-base64.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-bipbuffer.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-cache.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-crawler.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-crc32c.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-daemon.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-darwin_priv.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-extstore.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-freebsd_priv.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-items.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-itoa_ljust.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-jenkins_hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-linux_priv.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-logger.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-md5.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-memcached.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-murmur3_hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-openbsd_priv.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proto_bin.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proto_proxy.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proto_text.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proxy_await.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proxy_config.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proxy_internal.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proxy_jump_hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proxy_lua.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proxy_network.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proxy_request.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proxy_ring_hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proxy_ustats.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-proxy_xxhash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-restart.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-sasl_defs.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-slab_automove.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-slab_automove_extstore.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-slabs.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-solaris_priv.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-stats_prefix.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-storage.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-thread.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-tls.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcached_debug-util.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/murmur3_hash.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sizes.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stats_prefix.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/testapp.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/timedrun.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/util.Po@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .c.o: @am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $< .c.obj: @am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` memcached-memcached.o: memcached.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-memcached.o -MD -MP -MF $(DEPDIR)/memcached-memcached.Tpo -c -o memcached-memcached.o `test -f 'memcached.c' || echo '$(srcdir)/'`memcached.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-memcached.Tpo $(DEPDIR)/memcached-memcached.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='memcached.c' object='memcached-memcached.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-memcached.o `test -f 'memcached.c' || echo '$(srcdir)/'`memcached.c memcached-memcached.obj: memcached.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-memcached.obj -MD -MP -MF $(DEPDIR)/memcached-memcached.Tpo -c -o memcached-memcached.obj `if test -f 'memcached.c'; then $(CYGPATH_W) 'memcached.c'; else $(CYGPATH_W) '$(srcdir)/memcached.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-memcached.Tpo $(DEPDIR)/memcached-memcached.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='memcached.c' object='memcached-memcached.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-memcached.obj `if test -f 'memcached.c'; then $(CYGPATH_W) 'memcached.c'; else $(CYGPATH_W) '$(srcdir)/memcached.c'; fi` memcached-hash.o: hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-hash.o -MD -MP -MF $(DEPDIR)/memcached-hash.Tpo -c -o memcached-hash.o `test -f 'hash.c' || echo '$(srcdir)/'`hash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-hash.Tpo $(DEPDIR)/memcached-hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='hash.c' object='memcached-hash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-hash.o `test -f 'hash.c' || echo '$(srcdir)/'`hash.c memcached-hash.obj: hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-hash.obj -MD -MP -MF $(DEPDIR)/memcached-hash.Tpo -c -o memcached-hash.obj `if test -f 'hash.c'; then $(CYGPATH_W) 'hash.c'; else $(CYGPATH_W) '$(srcdir)/hash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-hash.Tpo $(DEPDIR)/memcached-hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='hash.c' object='memcached-hash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-hash.obj `if test -f 'hash.c'; then $(CYGPATH_W) 'hash.c'; else $(CYGPATH_W) '$(srcdir)/hash.c'; fi` memcached-jenkins_hash.o: jenkins_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-jenkins_hash.o -MD -MP -MF $(DEPDIR)/memcached-jenkins_hash.Tpo -c -o memcached-jenkins_hash.o `test -f 'jenkins_hash.c' || echo '$(srcdir)/'`jenkins_hash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-jenkins_hash.Tpo $(DEPDIR)/memcached-jenkins_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='jenkins_hash.c' object='memcached-jenkins_hash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-jenkins_hash.o `test -f 'jenkins_hash.c' || echo '$(srcdir)/'`jenkins_hash.c memcached-jenkins_hash.obj: jenkins_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-jenkins_hash.obj -MD -MP -MF $(DEPDIR)/memcached-jenkins_hash.Tpo -c -o memcached-jenkins_hash.obj `if test -f 'jenkins_hash.c'; then $(CYGPATH_W) 'jenkins_hash.c'; else $(CYGPATH_W) '$(srcdir)/jenkins_hash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-jenkins_hash.Tpo $(DEPDIR)/memcached-jenkins_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='jenkins_hash.c' object='memcached-jenkins_hash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-jenkins_hash.obj `if test -f 'jenkins_hash.c'; then $(CYGPATH_W) 'jenkins_hash.c'; else $(CYGPATH_W) '$(srcdir)/jenkins_hash.c'; fi` memcached-murmur3_hash.o: murmur3_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-murmur3_hash.o -MD -MP -MF $(DEPDIR)/memcached-murmur3_hash.Tpo -c -o memcached-murmur3_hash.o `test -f 'murmur3_hash.c' || echo '$(srcdir)/'`murmur3_hash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-murmur3_hash.Tpo $(DEPDIR)/memcached-murmur3_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='murmur3_hash.c' object='memcached-murmur3_hash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-murmur3_hash.o `test -f 'murmur3_hash.c' || echo '$(srcdir)/'`murmur3_hash.c memcached-murmur3_hash.obj: murmur3_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-murmur3_hash.obj -MD -MP -MF $(DEPDIR)/memcached-murmur3_hash.Tpo -c -o memcached-murmur3_hash.obj `if test -f 'murmur3_hash.c'; then $(CYGPATH_W) 'murmur3_hash.c'; else $(CYGPATH_W) '$(srcdir)/murmur3_hash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-murmur3_hash.Tpo $(DEPDIR)/memcached-murmur3_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='murmur3_hash.c' object='memcached-murmur3_hash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-murmur3_hash.obj `if test -f 'murmur3_hash.c'; then $(CYGPATH_W) 'murmur3_hash.c'; else $(CYGPATH_W) '$(srcdir)/murmur3_hash.c'; fi` memcached-slabs.o: slabs.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-slabs.o -MD -MP -MF $(DEPDIR)/memcached-slabs.Tpo -c -o memcached-slabs.o `test -f 'slabs.c' || echo '$(srcdir)/'`slabs.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-slabs.Tpo $(DEPDIR)/memcached-slabs.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slabs.c' object='memcached-slabs.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-slabs.o `test -f 'slabs.c' || echo '$(srcdir)/'`slabs.c memcached-slabs.obj: slabs.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-slabs.obj -MD -MP -MF $(DEPDIR)/memcached-slabs.Tpo -c -o memcached-slabs.obj `if test -f 'slabs.c'; then $(CYGPATH_W) 'slabs.c'; else $(CYGPATH_W) '$(srcdir)/slabs.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-slabs.Tpo $(DEPDIR)/memcached-slabs.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slabs.c' object='memcached-slabs.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-slabs.obj `if test -f 'slabs.c'; then $(CYGPATH_W) 'slabs.c'; else $(CYGPATH_W) '$(srcdir)/slabs.c'; fi` memcached-items.o: items.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-items.o -MD -MP -MF $(DEPDIR)/memcached-items.Tpo -c -o memcached-items.o `test -f 'items.c' || echo '$(srcdir)/'`items.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-items.Tpo $(DEPDIR)/memcached-items.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='items.c' object='memcached-items.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-items.o `test -f 'items.c' || echo '$(srcdir)/'`items.c memcached-items.obj: items.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-items.obj -MD -MP -MF $(DEPDIR)/memcached-items.Tpo -c -o memcached-items.obj `if test -f 'items.c'; then $(CYGPATH_W) 'items.c'; else $(CYGPATH_W) '$(srcdir)/items.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-items.Tpo $(DEPDIR)/memcached-items.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='items.c' object='memcached-items.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-items.obj `if test -f 'items.c'; then $(CYGPATH_W) 'items.c'; else $(CYGPATH_W) '$(srcdir)/items.c'; fi` memcached-assoc.o: assoc.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-assoc.o -MD -MP -MF $(DEPDIR)/memcached-assoc.Tpo -c -o memcached-assoc.o `test -f 'assoc.c' || echo '$(srcdir)/'`assoc.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-assoc.Tpo $(DEPDIR)/memcached-assoc.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assoc.c' object='memcached-assoc.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-assoc.o `test -f 'assoc.c' || echo '$(srcdir)/'`assoc.c memcached-assoc.obj: assoc.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-assoc.obj -MD -MP -MF $(DEPDIR)/memcached-assoc.Tpo -c -o memcached-assoc.obj `if test -f 'assoc.c'; then $(CYGPATH_W) 'assoc.c'; else $(CYGPATH_W) '$(srcdir)/assoc.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-assoc.Tpo $(DEPDIR)/memcached-assoc.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assoc.c' object='memcached-assoc.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-assoc.obj `if test -f 'assoc.c'; then $(CYGPATH_W) 'assoc.c'; else $(CYGPATH_W) '$(srcdir)/assoc.c'; fi` memcached-thread.o: thread.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-thread.o -MD -MP -MF $(DEPDIR)/memcached-thread.Tpo -c -o memcached-thread.o `test -f 'thread.c' || echo '$(srcdir)/'`thread.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-thread.Tpo $(DEPDIR)/memcached-thread.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='thread.c' object='memcached-thread.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-thread.o `test -f 'thread.c' || echo '$(srcdir)/'`thread.c memcached-thread.obj: thread.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-thread.obj -MD -MP -MF $(DEPDIR)/memcached-thread.Tpo -c -o memcached-thread.obj `if test -f 'thread.c'; then $(CYGPATH_W) 'thread.c'; else $(CYGPATH_W) '$(srcdir)/thread.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-thread.Tpo $(DEPDIR)/memcached-thread.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='thread.c' object='memcached-thread.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-thread.obj `if test -f 'thread.c'; then $(CYGPATH_W) 'thread.c'; else $(CYGPATH_W) '$(srcdir)/thread.c'; fi` memcached-daemon.o: daemon.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-daemon.o -MD -MP -MF $(DEPDIR)/memcached-daemon.Tpo -c -o memcached-daemon.o `test -f 'daemon.c' || echo '$(srcdir)/'`daemon.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-daemon.Tpo $(DEPDIR)/memcached-daemon.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='daemon.c' object='memcached-daemon.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-daemon.o `test -f 'daemon.c' || echo '$(srcdir)/'`daemon.c memcached-daemon.obj: daemon.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-daemon.obj -MD -MP -MF $(DEPDIR)/memcached-daemon.Tpo -c -o memcached-daemon.obj `if test -f 'daemon.c'; then $(CYGPATH_W) 'daemon.c'; else $(CYGPATH_W) '$(srcdir)/daemon.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-daemon.Tpo $(DEPDIR)/memcached-daemon.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='daemon.c' object='memcached-daemon.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-daemon.obj `if test -f 'daemon.c'; then $(CYGPATH_W) 'daemon.c'; else $(CYGPATH_W) '$(srcdir)/daemon.c'; fi` memcached-stats_prefix.o: stats_prefix.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-stats_prefix.o -MD -MP -MF $(DEPDIR)/memcached-stats_prefix.Tpo -c -o memcached-stats_prefix.o `test -f 'stats_prefix.c' || echo '$(srcdir)/'`stats_prefix.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-stats_prefix.Tpo $(DEPDIR)/memcached-stats_prefix.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='stats_prefix.c' object='memcached-stats_prefix.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-stats_prefix.o `test -f 'stats_prefix.c' || echo '$(srcdir)/'`stats_prefix.c memcached-stats_prefix.obj: stats_prefix.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-stats_prefix.obj -MD -MP -MF $(DEPDIR)/memcached-stats_prefix.Tpo -c -o memcached-stats_prefix.obj `if test -f 'stats_prefix.c'; then $(CYGPATH_W) 'stats_prefix.c'; else $(CYGPATH_W) '$(srcdir)/stats_prefix.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-stats_prefix.Tpo $(DEPDIR)/memcached-stats_prefix.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='stats_prefix.c' object='memcached-stats_prefix.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-stats_prefix.obj `if test -f 'stats_prefix.c'; then $(CYGPATH_W) 'stats_prefix.c'; else $(CYGPATH_W) '$(srcdir)/stats_prefix.c'; fi` memcached-util.o: util.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-util.o -MD -MP -MF $(DEPDIR)/memcached-util.Tpo -c -o memcached-util.o `test -f 'util.c' || echo '$(srcdir)/'`util.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-util.Tpo $(DEPDIR)/memcached-util.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='util.c' object='memcached-util.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-util.o `test -f 'util.c' || echo '$(srcdir)/'`util.c memcached-util.obj: util.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-util.obj -MD -MP -MF $(DEPDIR)/memcached-util.Tpo -c -o memcached-util.obj `if test -f 'util.c'; then $(CYGPATH_W) 'util.c'; else $(CYGPATH_W) '$(srcdir)/util.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-util.Tpo $(DEPDIR)/memcached-util.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='util.c' object='memcached-util.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-util.obj `if test -f 'util.c'; then $(CYGPATH_W) 'util.c'; else $(CYGPATH_W) '$(srcdir)/util.c'; fi` memcached-cache.o: cache.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-cache.o -MD -MP -MF $(DEPDIR)/memcached-cache.Tpo -c -o memcached-cache.o `test -f 'cache.c' || echo '$(srcdir)/'`cache.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-cache.Tpo $(DEPDIR)/memcached-cache.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='cache.c' object='memcached-cache.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-cache.o `test -f 'cache.c' || echo '$(srcdir)/'`cache.c memcached-cache.obj: cache.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-cache.obj -MD -MP -MF $(DEPDIR)/memcached-cache.Tpo -c -o memcached-cache.obj `if test -f 'cache.c'; then $(CYGPATH_W) 'cache.c'; else $(CYGPATH_W) '$(srcdir)/cache.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-cache.Tpo $(DEPDIR)/memcached-cache.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='cache.c' object='memcached-cache.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-cache.obj `if test -f 'cache.c'; then $(CYGPATH_W) 'cache.c'; else $(CYGPATH_W) '$(srcdir)/cache.c'; fi` memcached-bipbuffer.o: bipbuffer.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-bipbuffer.o -MD -MP -MF $(DEPDIR)/memcached-bipbuffer.Tpo -c -o memcached-bipbuffer.o `test -f 'bipbuffer.c' || echo '$(srcdir)/'`bipbuffer.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-bipbuffer.Tpo $(DEPDIR)/memcached-bipbuffer.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='bipbuffer.c' object='memcached-bipbuffer.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-bipbuffer.o `test -f 'bipbuffer.c' || echo '$(srcdir)/'`bipbuffer.c memcached-bipbuffer.obj: bipbuffer.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-bipbuffer.obj -MD -MP -MF $(DEPDIR)/memcached-bipbuffer.Tpo -c -o memcached-bipbuffer.obj `if test -f 'bipbuffer.c'; then $(CYGPATH_W) 'bipbuffer.c'; else $(CYGPATH_W) '$(srcdir)/bipbuffer.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-bipbuffer.Tpo $(DEPDIR)/memcached-bipbuffer.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='bipbuffer.c' object='memcached-bipbuffer.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-bipbuffer.obj `if test -f 'bipbuffer.c'; then $(CYGPATH_W) 'bipbuffer.c'; else $(CYGPATH_W) '$(srcdir)/bipbuffer.c'; fi` memcached-base64.o: base64.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-base64.o -MD -MP -MF $(DEPDIR)/memcached-base64.Tpo -c -o memcached-base64.o `test -f 'base64.c' || echo '$(srcdir)/'`base64.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-base64.Tpo $(DEPDIR)/memcached-base64.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='base64.c' object='memcached-base64.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-base64.o `test -f 'base64.c' || echo '$(srcdir)/'`base64.c memcached-base64.obj: base64.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-base64.obj -MD -MP -MF $(DEPDIR)/memcached-base64.Tpo -c -o memcached-base64.obj `if test -f 'base64.c'; then $(CYGPATH_W) 'base64.c'; else $(CYGPATH_W) '$(srcdir)/base64.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-base64.Tpo $(DEPDIR)/memcached-base64.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='base64.c' object='memcached-base64.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-base64.obj `if test -f 'base64.c'; then $(CYGPATH_W) 'base64.c'; else $(CYGPATH_W) '$(srcdir)/base64.c'; fi` memcached-logger.o: logger.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-logger.o -MD -MP -MF $(DEPDIR)/memcached-logger.Tpo -c -o memcached-logger.o `test -f 'logger.c' || echo '$(srcdir)/'`logger.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-logger.Tpo $(DEPDIR)/memcached-logger.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='logger.c' object='memcached-logger.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-logger.o `test -f 'logger.c' || echo '$(srcdir)/'`logger.c memcached-logger.obj: logger.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-logger.obj -MD -MP -MF $(DEPDIR)/memcached-logger.Tpo -c -o memcached-logger.obj `if test -f 'logger.c'; then $(CYGPATH_W) 'logger.c'; else $(CYGPATH_W) '$(srcdir)/logger.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-logger.Tpo $(DEPDIR)/memcached-logger.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='logger.c' object='memcached-logger.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-logger.obj `if test -f 'logger.c'; then $(CYGPATH_W) 'logger.c'; else $(CYGPATH_W) '$(srcdir)/logger.c'; fi` memcached-crawler.o: crawler.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-crawler.o -MD -MP -MF $(DEPDIR)/memcached-crawler.Tpo -c -o memcached-crawler.o `test -f 'crawler.c' || echo '$(srcdir)/'`crawler.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-crawler.Tpo $(DEPDIR)/memcached-crawler.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='crawler.c' object='memcached-crawler.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-crawler.o `test -f 'crawler.c' || echo '$(srcdir)/'`crawler.c memcached-crawler.obj: crawler.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-crawler.obj -MD -MP -MF $(DEPDIR)/memcached-crawler.Tpo -c -o memcached-crawler.obj `if test -f 'crawler.c'; then $(CYGPATH_W) 'crawler.c'; else $(CYGPATH_W) '$(srcdir)/crawler.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-crawler.Tpo $(DEPDIR)/memcached-crawler.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='crawler.c' object='memcached-crawler.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-crawler.obj `if test -f 'crawler.c'; then $(CYGPATH_W) 'crawler.c'; else $(CYGPATH_W) '$(srcdir)/crawler.c'; fi` memcached-itoa_ljust.o: itoa_ljust.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-itoa_ljust.o -MD -MP -MF $(DEPDIR)/memcached-itoa_ljust.Tpo -c -o memcached-itoa_ljust.o `test -f 'itoa_ljust.c' || echo '$(srcdir)/'`itoa_ljust.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-itoa_ljust.Tpo $(DEPDIR)/memcached-itoa_ljust.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='itoa_ljust.c' object='memcached-itoa_ljust.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-itoa_ljust.o `test -f 'itoa_ljust.c' || echo '$(srcdir)/'`itoa_ljust.c memcached-itoa_ljust.obj: itoa_ljust.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-itoa_ljust.obj -MD -MP -MF $(DEPDIR)/memcached-itoa_ljust.Tpo -c -o memcached-itoa_ljust.obj `if test -f 'itoa_ljust.c'; then $(CYGPATH_W) 'itoa_ljust.c'; else $(CYGPATH_W) '$(srcdir)/itoa_ljust.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-itoa_ljust.Tpo $(DEPDIR)/memcached-itoa_ljust.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='itoa_ljust.c' object='memcached-itoa_ljust.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-itoa_ljust.obj `if test -f 'itoa_ljust.c'; then $(CYGPATH_W) 'itoa_ljust.c'; else $(CYGPATH_W) '$(srcdir)/itoa_ljust.c'; fi` memcached-slab_automove.o: slab_automove.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-slab_automove.o -MD -MP -MF $(DEPDIR)/memcached-slab_automove.Tpo -c -o memcached-slab_automove.o `test -f 'slab_automove.c' || echo '$(srcdir)/'`slab_automove.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-slab_automove.Tpo $(DEPDIR)/memcached-slab_automove.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slab_automove.c' object='memcached-slab_automove.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-slab_automove.o `test -f 'slab_automove.c' || echo '$(srcdir)/'`slab_automove.c memcached-slab_automove.obj: slab_automove.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-slab_automove.obj -MD -MP -MF $(DEPDIR)/memcached-slab_automove.Tpo -c -o memcached-slab_automove.obj `if test -f 'slab_automove.c'; then $(CYGPATH_W) 'slab_automove.c'; else $(CYGPATH_W) '$(srcdir)/slab_automove.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-slab_automove.Tpo $(DEPDIR)/memcached-slab_automove.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slab_automove.c' object='memcached-slab_automove.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-slab_automove.obj `if test -f 'slab_automove.c'; then $(CYGPATH_W) 'slab_automove.c'; else $(CYGPATH_W) '$(srcdir)/slab_automove.c'; fi` memcached-authfile.o: authfile.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-authfile.o -MD -MP -MF $(DEPDIR)/memcached-authfile.Tpo -c -o memcached-authfile.o `test -f 'authfile.c' || echo '$(srcdir)/'`authfile.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-authfile.Tpo $(DEPDIR)/memcached-authfile.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='authfile.c' object='memcached-authfile.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-authfile.o `test -f 'authfile.c' || echo '$(srcdir)/'`authfile.c memcached-authfile.obj: authfile.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-authfile.obj -MD -MP -MF $(DEPDIR)/memcached-authfile.Tpo -c -o memcached-authfile.obj `if test -f 'authfile.c'; then $(CYGPATH_W) 'authfile.c'; else $(CYGPATH_W) '$(srcdir)/authfile.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-authfile.Tpo $(DEPDIR)/memcached-authfile.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='authfile.c' object='memcached-authfile.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-authfile.obj `if test -f 'authfile.c'; then $(CYGPATH_W) 'authfile.c'; else $(CYGPATH_W) '$(srcdir)/authfile.c'; fi` memcached-restart.o: restart.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-restart.o -MD -MP -MF $(DEPDIR)/memcached-restart.Tpo -c -o memcached-restart.o `test -f 'restart.c' || echo '$(srcdir)/'`restart.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-restart.Tpo $(DEPDIR)/memcached-restart.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='restart.c' object='memcached-restart.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-restart.o `test -f 'restart.c' || echo '$(srcdir)/'`restart.c memcached-restart.obj: restart.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-restart.obj -MD -MP -MF $(DEPDIR)/memcached-restart.Tpo -c -o memcached-restart.obj `if test -f 'restart.c'; then $(CYGPATH_W) 'restart.c'; else $(CYGPATH_W) '$(srcdir)/restart.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-restart.Tpo $(DEPDIR)/memcached-restart.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='restart.c' object='memcached-restart.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-restart.obj `if test -f 'restart.c'; then $(CYGPATH_W) 'restart.c'; else $(CYGPATH_W) '$(srcdir)/restart.c'; fi` memcached-proto_text.o: proto_text.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proto_text.o -MD -MP -MF $(DEPDIR)/memcached-proto_text.Tpo -c -o memcached-proto_text.o `test -f 'proto_text.c' || echo '$(srcdir)/'`proto_text.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proto_text.Tpo $(DEPDIR)/memcached-proto_text.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_text.c' object='memcached-proto_text.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proto_text.o `test -f 'proto_text.c' || echo '$(srcdir)/'`proto_text.c memcached-proto_text.obj: proto_text.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proto_text.obj -MD -MP -MF $(DEPDIR)/memcached-proto_text.Tpo -c -o memcached-proto_text.obj `if test -f 'proto_text.c'; then $(CYGPATH_W) 'proto_text.c'; else $(CYGPATH_W) '$(srcdir)/proto_text.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proto_text.Tpo $(DEPDIR)/memcached-proto_text.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_text.c' object='memcached-proto_text.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proto_text.obj `if test -f 'proto_text.c'; then $(CYGPATH_W) 'proto_text.c'; else $(CYGPATH_W) '$(srcdir)/proto_text.c'; fi` memcached-proto_bin.o: proto_bin.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proto_bin.o -MD -MP -MF $(DEPDIR)/memcached-proto_bin.Tpo -c -o memcached-proto_bin.o `test -f 'proto_bin.c' || echo '$(srcdir)/'`proto_bin.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proto_bin.Tpo $(DEPDIR)/memcached-proto_bin.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_bin.c' object='memcached-proto_bin.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proto_bin.o `test -f 'proto_bin.c' || echo '$(srcdir)/'`proto_bin.c memcached-proto_bin.obj: proto_bin.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proto_bin.obj -MD -MP -MF $(DEPDIR)/memcached-proto_bin.Tpo -c -o memcached-proto_bin.obj `if test -f 'proto_bin.c'; then $(CYGPATH_W) 'proto_bin.c'; else $(CYGPATH_W) '$(srcdir)/proto_bin.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proto_bin.Tpo $(DEPDIR)/memcached-proto_bin.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_bin.c' object='memcached-proto_bin.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proto_bin.obj `if test -f 'proto_bin.c'; then $(CYGPATH_W) 'proto_bin.c'; else $(CYGPATH_W) '$(srcdir)/proto_bin.c'; fi` memcached-solaris_priv.o: solaris_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-solaris_priv.o -MD -MP -MF $(DEPDIR)/memcached-solaris_priv.Tpo -c -o memcached-solaris_priv.o `test -f 'solaris_priv.c' || echo '$(srcdir)/'`solaris_priv.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-solaris_priv.Tpo $(DEPDIR)/memcached-solaris_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='solaris_priv.c' object='memcached-solaris_priv.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-solaris_priv.o `test -f 'solaris_priv.c' || echo '$(srcdir)/'`solaris_priv.c memcached-solaris_priv.obj: solaris_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-solaris_priv.obj -MD -MP -MF $(DEPDIR)/memcached-solaris_priv.Tpo -c -o memcached-solaris_priv.obj `if test -f 'solaris_priv.c'; then $(CYGPATH_W) 'solaris_priv.c'; else $(CYGPATH_W) '$(srcdir)/solaris_priv.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-solaris_priv.Tpo $(DEPDIR)/memcached-solaris_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='solaris_priv.c' object='memcached-solaris_priv.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-solaris_priv.obj `if test -f 'solaris_priv.c'; then $(CYGPATH_W) 'solaris_priv.c'; else $(CYGPATH_W) '$(srcdir)/solaris_priv.c'; fi` memcached-linux_priv.o: linux_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-linux_priv.o -MD -MP -MF $(DEPDIR)/memcached-linux_priv.Tpo -c -o memcached-linux_priv.o `test -f 'linux_priv.c' || echo '$(srcdir)/'`linux_priv.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-linux_priv.Tpo $(DEPDIR)/memcached-linux_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='linux_priv.c' object='memcached-linux_priv.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-linux_priv.o `test -f 'linux_priv.c' || echo '$(srcdir)/'`linux_priv.c memcached-linux_priv.obj: linux_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-linux_priv.obj -MD -MP -MF $(DEPDIR)/memcached-linux_priv.Tpo -c -o memcached-linux_priv.obj `if test -f 'linux_priv.c'; then $(CYGPATH_W) 'linux_priv.c'; else $(CYGPATH_W) '$(srcdir)/linux_priv.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-linux_priv.Tpo $(DEPDIR)/memcached-linux_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='linux_priv.c' object='memcached-linux_priv.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-linux_priv.obj `if test -f 'linux_priv.c'; then $(CYGPATH_W) 'linux_priv.c'; else $(CYGPATH_W) '$(srcdir)/linux_priv.c'; fi` memcached-openbsd_priv.o: openbsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-openbsd_priv.o -MD -MP -MF $(DEPDIR)/memcached-openbsd_priv.Tpo -c -o memcached-openbsd_priv.o `test -f 'openbsd_priv.c' || echo '$(srcdir)/'`openbsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-openbsd_priv.Tpo $(DEPDIR)/memcached-openbsd_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='openbsd_priv.c' object='memcached-openbsd_priv.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-openbsd_priv.o `test -f 'openbsd_priv.c' || echo '$(srcdir)/'`openbsd_priv.c memcached-openbsd_priv.obj: openbsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-openbsd_priv.obj -MD -MP -MF $(DEPDIR)/memcached-openbsd_priv.Tpo -c -o memcached-openbsd_priv.obj `if test -f 'openbsd_priv.c'; then $(CYGPATH_W) 'openbsd_priv.c'; else $(CYGPATH_W) '$(srcdir)/openbsd_priv.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-openbsd_priv.Tpo $(DEPDIR)/memcached-openbsd_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='openbsd_priv.c' object='memcached-openbsd_priv.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-openbsd_priv.obj `if test -f 'openbsd_priv.c'; then $(CYGPATH_W) 'openbsd_priv.c'; else $(CYGPATH_W) '$(srcdir)/openbsd_priv.c'; fi` memcached-freebsd_priv.o: freebsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-freebsd_priv.o -MD -MP -MF $(DEPDIR)/memcached-freebsd_priv.Tpo -c -o memcached-freebsd_priv.o `test -f 'freebsd_priv.c' || echo '$(srcdir)/'`freebsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-freebsd_priv.Tpo $(DEPDIR)/memcached-freebsd_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='freebsd_priv.c' object='memcached-freebsd_priv.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-freebsd_priv.o `test -f 'freebsd_priv.c' || echo '$(srcdir)/'`freebsd_priv.c memcached-freebsd_priv.obj: freebsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-freebsd_priv.obj -MD -MP -MF $(DEPDIR)/memcached-freebsd_priv.Tpo -c -o memcached-freebsd_priv.obj `if test -f 'freebsd_priv.c'; then $(CYGPATH_W) 'freebsd_priv.c'; else $(CYGPATH_W) '$(srcdir)/freebsd_priv.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-freebsd_priv.Tpo $(DEPDIR)/memcached-freebsd_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='freebsd_priv.c' object='memcached-freebsd_priv.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-freebsd_priv.obj `if test -f 'freebsd_priv.c'; then $(CYGPATH_W) 'freebsd_priv.c'; else $(CYGPATH_W) '$(srcdir)/freebsd_priv.c'; fi` memcached-darwin_priv.o: darwin_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-darwin_priv.o -MD -MP -MF $(DEPDIR)/memcached-darwin_priv.Tpo -c -o memcached-darwin_priv.o `test -f 'darwin_priv.c' || echo '$(srcdir)/'`darwin_priv.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-darwin_priv.Tpo $(DEPDIR)/memcached-darwin_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='darwin_priv.c' object='memcached-darwin_priv.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-darwin_priv.o `test -f 'darwin_priv.c' || echo '$(srcdir)/'`darwin_priv.c memcached-darwin_priv.obj: darwin_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-darwin_priv.obj -MD -MP -MF $(DEPDIR)/memcached-darwin_priv.Tpo -c -o memcached-darwin_priv.obj `if test -f 'darwin_priv.c'; then $(CYGPATH_W) 'darwin_priv.c'; else $(CYGPATH_W) '$(srcdir)/darwin_priv.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-darwin_priv.Tpo $(DEPDIR)/memcached-darwin_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='darwin_priv.c' object='memcached-darwin_priv.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-darwin_priv.obj `if test -f 'darwin_priv.c'; then $(CYGPATH_W) 'darwin_priv.c'; else $(CYGPATH_W) '$(srcdir)/darwin_priv.c'; fi` memcached-sasl_defs.o: sasl_defs.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-sasl_defs.o -MD -MP -MF $(DEPDIR)/memcached-sasl_defs.Tpo -c -o memcached-sasl_defs.o `test -f 'sasl_defs.c' || echo '$(srcdir)/'`sasl_defs.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-sasl_defs.Tpo $(DEPDIR)/memcached-sasl_defs.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='sasl_defs.c' object='memcached-sasl_defs.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-sasl_defs.o `test -f 'sasl_defs.c' || echo '$(srcdir)/'`sasl_defs.c memcached-sasl_defs.obj: sasl_defs.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-sasl_defs.obj -MD -MP -MF $(DEPDIR)/memcached-sasl_defs.Tpo -c -o memcached-sasl_defs.obj `if test -f 'sasl_defs.c'; then $(CYGPATH_W) 'sasl_defs.c'; else $(CYGPATH_W) '$(srcdir)/sasl_defs.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-sasl_defs.Tpo $(DEPDIR)/memcached-sasl_defs.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='sasl_defs.c' object='memcached-sasl_defs.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-sasl_defs.obj `if test -f 'sasl_defs.c'; then $(CYGPATH_W) 'sasl_defs.c'; else $(CYGPATH_W) '$(srcdir)/sasl_defs.c'; fi` memcached-proto_proxy.o: proto_proxy.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proto_proxy.o -MD -MP -MF $(DEPDIR)/memcached-proto_proxy.Tpo -c -o memcached-proto_proxy.o `test -f 'proto_proxy.c' || echo '$(srcdir)/'`proto_proxy.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proto_proxy.Tpo $(DEPDIR)/memcached-proto_proxy.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_proxy.c' object='memcached-proto_proxy.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proto_proxy.o `test -f 'proto_proxy.c' || echo '$(srcdir)/'`proto_proxy.c memcached-proto_proxy.obj: proto_proxy.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proto_proxy.obj -MD -MP -MF $(DEPDIR)/memcached-proto_proxy.Tpo -c -o memcached-proto_proxy.obj `if test -f 'proto_proxy.c'; then $(CYGPATH_W) 'proto_proxy.c'; else $(CYGPATH_W) '$(srcdir)/proto_proxy.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proto_proxy.Tpo $(DEPDIR)/memcached-proto_proxy.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_proxy.c' object='memcached-proto_proxy.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proto_proxy.obj `if test -f 'proto_proxy.c'; then $(CYGPATH_W) 'proto_proxy.c'; else $(CYGPATH_W) '$(srcdir)/proto_proxy.c'; fi` memcached-proxy_xxhash.o: proxy_xxhash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_xxhash.o -MD -MP -MF $(DEPDIR)/memcached-proxy_xxhash.Tpo -c -o memcached-proxy_xxhash.o `test -f 'proxy_xxhash.c' || echo '$(srcdir)/'`proxy_xxhash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_xxhash.Tpo $(DEPDIR)/memcached-proxy_xxhash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_xxhash.c' object='memcached-proxy_xxhash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_xxhash.o `test -f 'proxy_xxhash.c' || echo '$(srcdir)/'`proxy_xxhash.c memcached-proxy_xxhash.obj: proxy_xxhash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_xxhash.obj -MD -MP -MF $(DEPDIR)/memcached-proxy_xxhash.Tpo -c -o memcached-proxy_xxhash.obj `if test -f 'proxy_xxhash.c'; then $(CYGPATH_W) 'proxy_xxhash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_xxhash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_xxhash.Tpo $(DEPDIR)/memcached-proxy_xxhash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_xxhash.c' object='memcached-proxy_xxhash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_xxhash.obj `if test -f 'proxy_xxhash.c'; then $(CYGPATH_W) 'proxy_xxhash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_xxhash.c'; fi` memcached-proxy_await.o: proxy_await.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_await.o -MD -MP -MF $(DEPDIR)/memcached-proxy_await.Tpo -c -o memcached-proxy_await.o `test -f 'proxy_await.c' || echo '$(srcdir)/'`proxy_await.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_await.Tpo $(DEPDIR)/memcached-proxy_await.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_await.c' object='memcached-proxy_await.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_await.o `test -f 'proxy_await.c' || echo '$(srcdir)/'`proxy_await.c memcached-proxy_await.obj: proxy_await.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_await.obj -MD -MP -MF $(DEPDIR)/memcached-proxy_await.Tpo -c -o memcached-proxy_await.obj `if test -f 'proxy_await.c'; then $(CYGPATH_W) 'proxy_await.c'; else $(CYGPATH_W) '$(srcdir)/proxy_await.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_await.Tpo $(DEPDIR)/memcached-proxy_await.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_await.c' object='memcached-proxy_await.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_await.obj `if test -f 'proxy_await.c'; then $(CYGPATH_W) 'proxy_await.c'; else $(CYGPATH_W) '$(srcdir)/proxy_await.c'; fi` memcached-proxy_ustats.o: proxy_ustats.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_ustats.o -MD -MP -MF $(DEPDIR)/memcached-proxy_ustats.Tpo -c -o memcached-proxy_ustats.o `test -f 'proxy_ustats.c' || echo '$(srcdir)/'`proxy_ustats.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_ustats.Tpo $(DEPDIR)/memcached-proxy_ustats.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_ustats.c' object='memcached-proxy_ustats.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_ustats.o `test -f 'proxy_ustats.c' || echo '$(srcdir)/'`proxy_ustats.c memcached-proxy_ustats.obj: proxy_ustats.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_ustats.obj -MD -MP -MF $(DEPDIR)/memcached-proxy_ustats.Tpo -c -o memcached-proxy_ustats.obj `if test -f 'proxy_ustats.c'; then $(CYGPATH_W) 'proxy_ustats.c'; else $(CYGPATH_W) '$(srcdir)/proxy_ustats.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_ustats.Tpo $(DEPDIR)/memcached-proxy_ustats.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_ustats.c' object='memcached-proxy_ustats.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_ustats.obj `if test -f 'proxy_ustats.c'; then $(CYGPATH_W) 'proxy_ustats.c'; else $(CYGPATH_W) '$(srcdir)/proxy_ustats.c'; fi` memcached-proxy_jump_hash.o: proxy_jump_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_jump_hash.o -MD -MP -MF $(DEPDIR)/memcached-proxy_jump_hash.Tpo -c -o memcached-proxy_jump_hash.o `test -f 'proxy_jump_hash.c' || echo '$(srcdir)/'`proxy_jump_hash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_jump_hash.Tpo $(DEPDIR)/memcached-proxy_jump_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_jump_hash.c' object='memcached-proxy_jump_hash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_jump_hash.o `test -f 'proxy_jump_hash.c' || echo '$(srcdir)/'`proxy_jump_hash.c memcached-proxy_jump_hash.obj: proxy_jump_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_jump_hash.obj -MD -MP -MF $(DEPDIR)/memcached-proxy_jump_hash.Tpo -c -o memcached-proxy_jump_hash.obj `if test -f 'proxy_jump_hash.c'; then $(CYGPATH_W) 'proxy_jump_hash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_jump_hash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_jump_hash.Tpo $(DEPDIR)/memcached-proxy_jump_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_jump_hash.c' object='memcached-proxy_jump_hash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_jump_hash.obj `if test -f 'proxy_jump_hash.c'; then $(CYGPATH_W) 'proxy_jump_hash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_jump_hash.c'; fi` memcached-proxy_request.o: proxy_request.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_request.o -MD -MP -MF $(DEPDIR)/memcached-proxy_request.Tpo -c -o memcached-proxy_request.o `test -f 'proxy_request.c' || echo '$(srcdir)/'`proxy_request.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_request.Tpo $(DEPDIR)/memcached-proxy_request.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_request.c' object='memcached-proxy_request.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_request.o `test -f 'proxy_request.c' || echo '$(srcdir)/'`proxy_request.c memcached-proxy_request.obj: proxy_request.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_request.obj -MD -MP -MF $(DEPDIR)/memcached-proxy_request.Tpo -c -o memcached-proxy_request.obj `if test -f 'proxy_request.c'; then $(CYGPATH_W) 'proxy_request.c'; else $(CYGPATH_W) '$(srcdir)/proxy_request.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_request.Tpo $(DEPDIR)/memcached-proxy_request.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_request.c' object='memcached-proxy_request.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_request.obj `if test -f 'proxy_request.c'; then $(CYGPATH_W) 'proxy_request.c'; else $(CYGPATH_W) '$(srcdir)/proxy_request.c'; fi` memcached-proxy_network.o: proxy_network.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_network.o -MD -MP -MF $(DEPDIR)/memcached-proxy_network.Tpo -c -o memcached-proxy_network.o `test -f 'proxy_network.c' || echo '$(srcdir)/'`proxy_network.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_network.Tpo $(DEPDIR)/memcached-proxy_network.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_network.c' object='memcached-proxy_network.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_network.o `test -f 'proxy_network.c' || echo '$(srcdir)/'`proxy_network.c memcached-proxy_network.obj: proxy_network.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_network.obj -MD -MP -MF $(DEPDIR)/memcached-proxy_network.Tpo -c -o memcached-proxy_network.obj `if test -f 'proxy_network.c'; then $(CYGPATH_W) 'proxy_network.c'; else $(CYGPATH_W) '$(srcdir)/proxy_network.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_network.Tpo $(DEPDIR)/memcached-proxy_network.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_network.c' object='memcached-proxy_network.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_network.obj `if test -f 'proxy_network.c'; then $(CYGPATH_W) 'proxy_network.c'; else $(CYGPATH_W) '$(srcdir)/proxy_network.c'; fi` memcached-proxy_lua.o: proxy_lua.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_lua.o -MD -MP -MF $(DEPDIR)/memcached-proxy_lua.Tpo -c -o memcached-proxy_lua.o `test -f 'proxy_lua.c' || echo '$(srcdir)/'`proxy_lua.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_lua.Tpo $(DEPDIR)/memcached-proxy_lua.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_lua.c' object='memcached-proxy_lua.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_lua.o `test -f 'proxy_lua.c' || echo '$(srcdir)/'`proxy_lua.c memcached-proxy_lua.obj: proxy_lua.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_lua.obj -MD -MP -MF $(DEPDIR)/memcached-proxy_lua.Tpo -c -o memcached-proxy_lua.obj `if test -f 'proxy_lua.c'; then $(CYGPATH_W) 'proxy_lua.c'; else $(CYGPATH_W) '$(srcdir)/proxy_lua.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_lua.Tpo $(DEPDIR)/memcached-proxy_lua.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_lua.c' object='memcached-proxy_lua.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_lua.obj `if test -f 'proxy_lua.c'; then $(CYGPATH_W) 'proxy_lua.c'; else $(CYGPATH_W) '$(srcdir)/proxy_lua.c'; fi` memcached-proxy_config.o: proxy_config.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_config.o -MD -MP -MF $(DEPDIR)/memcached-proxy_config.Tpo -c -o memcached-proxy_config.o `test -f 'proxy_config.c' || echo '$(srcdir)/'`proxy_config.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_config.Tpo $(DEPDIR)/memcached-proxy_config.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_config.c' object='memcached-proxy_config.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_config.o `test -f 'proxy_config.c' || echo '$(srcdir)/'`proxy_config.c memcached-proxy_config.obj: proxy_config.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_config.obj -MD -MP -MF $(DEPDIR)/memcached-proxy_config.Tpo -c -o memcached-proxy_config.obj `if test -f 'proxy_config.c'; then $(CYGPATH_W) 'proxy_config.c'; else $(CYGPATH_W) '$(srcdir)/proxy_config.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_config.Tpo $(DEPDIR)/memcached-proxy_config.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_config.c' object='memcached-proxy_config.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_config.obj `if test -f 'proxy_config.c'; then $(CYGPATH_W) 'proxy_config.c'; else $(CYGPATH_W) '$(srcdir)/proxy_config.c'; fi` memcached-proxy_ring_hash.o: proxy_ring_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_ring_hash.o -MD -MP -MF $(DEPDIR)/memcached-proxy_ring_hash.Tpo -c -o memcached-proxy_ring_hash.o `test -f 'proxy_ring_hash.c' || echo '$(srcdir)/'`proxy_ring_hash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_ring_hash.Tpo $(DEPDIR)/memcached-proxy_ring_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_ring_hash.c' object='memcached-proxy_ring_hash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_ring_hash.o `test -f 'proxy_ring_hash.c' || echo '$(srcdir)/'`proxy_ring_hash.c memcached-proxy_ring_hash.obj: proxy_ring_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_ring_hash.obj -MD -MP -MF $(DEPDIR)/memcached-proxy_ring_hash.Tpo -c -o memcached-proxy_ring_hash.obj `if test -f 'proxy_ring_hash.c'; then $(CYGPATH_W) 'proxy_ring_hash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_ring_hash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_ring_hash.Tpo $(DEPDIR)/memcached-proxy_ring_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_ring_hash.c' object='memcached-proxy_ring_hash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_ring_hash.obj `if test -f 'proxy_ring_hash.c'; then $(CYGPATH_W) 'proxy_ring_hash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_ring_hash.c'; fi` memcached-proxy_internal.o: proxy_internal.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_internal.o -MD -MP -MF $(DEPDIR)/memcached-proxy_internal.Tpo -c -o memcached-proxy_internal.o `test -f 'proxy_internal.c' || echo '$(srcdir)/'`proxy_internal.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_internal.Tpo $(DEPDIR)/memcached-proxy_internal.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_internal.c' object='memcached-proxy_internal.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_internal.o `test -f 'proxy_internal.c' || echo '$(srcdir)/'`proxy_internal.c memcached-proxy_internal.obj: proxy_internal.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-proxy_internal.obj -MD -MP -MF $(DEPDIR)/memcached-proxy_internal.Tpo -c -o memcached-proxy_internal.obj `if test -f 'proxy_internal.c'; then $(CYGPATH_W) 'proxy_internal.c'; else $(CYGPATH_W) '$(srcdir)/proxy_internal.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-proxy_internal.Tpo $(DEPDIR)/memcached-proxy_internal.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_internal.c' object='memcached-proxy_internal.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-proxy_internal.obj `if test -f 'proxy_internal.c'; then $(CYGPATH_W) 'proxy_internal.c'; else $(CYGPATH_W) '$(srcdir)/proxy_internal.c'; fi` memcached-md5.o: md5.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-md5.o -MD -MP -MF $(DEPDIR)/memcached-md5.Tpo -c -o memcached-md5.o `test -f 'md5.c' || echo '$(srcdir)/'`md5.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-md5.Tpo $(DEPDIR)/memcached-md5.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='md5.c' object='memcached-md5.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-md5.o `test -f 'md5.c' || echo '$(srcdir)/'`md5.c memcached-md5.obj: md5.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-md5.obj -MD -MP -MF $(DEPDIR)/memcached-md5.Tpo -c -o memcached-md5.obj `if test -f 'md5.c'; then $(CYGPATH_W) 'md5.c'; else $(CYGPATH_W) '$(srcdir)/md5.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-md5.Tpo $(DEPDIR)/memcached-md5.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='md5.c' object='memcached-md5.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-md5.obj `if test -f 'md5.c'; then $(CYGPATH_W) 'md5.c'; else $(CYGPATH_W) '$(srcdir)/md5.c'; fi` memcached-extstore.o: extstore.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-extstore.o -MD -MP -MF $(DEPDIR)/memcached-extstore.Tpo -c -o memcached-extstore.o `test -f 'extstore.c' || echo '$(srcdir)/'`extstore.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-extstore.Tpo $(DEPDIR)/memcached-extstore.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='extstore.c' object='memcached-extstore.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-extstore.o `test -f 'extstore.c' || echo '$(srcdir)/'`extstore.c memcached-extstore.obj: extstore.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-extstore.obj -MD -MP -MF $(DEPDIR)/memcached-extstore.Tpo -c -o memcached-extstore.obj `if test -f 'extstore.c'; then $(CYGPATH_W) 'extstore.c'; else $(CYGPATH_W) '$(srcdir)/extstore.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-extstore.Tpo $(DEPDIR)/memcached-extstore.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='extstore.c' object='memcached-extstore.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-extstore.obj `if test -f 'extstore.c'; then $(CYGPATH_W) 'extstore.c'; else $(CYGPATH_W) '$(srcdir)/extstore.c'; fi` memcached-crc32c.o: crc32c.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-crc32c.o -MD -MP -MF $(DEPDIR)/memcached-crc32c.Tpo -c -o memcached-crc32c.o `test -f 'crc32c.c' || echo '$(srcdir)/'`crc32c.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-crc32c.Tpo $(DEPDIR)/memcached-crc32c.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='crc32c.c' object='memcached-crc32c.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-crc32c.o `test -f 'crc32c.c' || echo '$(srcdir)/'`crc32c.c memcached-crc32c.obj: crc32c.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-crc32c.obj -MD -MP -MF $(DEPDIR)/memcached-crc32c.Tpo -c -o memcached-crc32c.obj `if test -f 'crc32c.c'; then $(CYGPATH_W) 'crc32c.c'; else $(CYGPATH_W) '$(srcdir)/crc32c.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-crc32c.Tpo $(DEPDIR)/memcached-crc32c.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='crc32c.c' object='memcached-crc32c.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-crc32c.obj `if test -f 'crc32c.c'; then $(CYGPATH_W) 'crc32c.c'; else $(CYGPATH_W) '$(srcdir)/crc32c.c'; fi` memcached-storage.o: storage.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-storage.o -MD -MP -MF $(DEPDIR)/memcached-storage.Tpo -c -o memcached-storage.o `test -f 'storage.c' || echo '$(srcdir)/'`storage.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-storage.Tpo $(DEPDIR)/memcached-storage.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='storage.c' object='memcached-storage.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-storage.o `test -f 'storage.c' || echo '$(srcdir)/'`storage.c memcached-storage.obj: storage.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-storage.obj -MD -MP -MF $(DEPDIR)/memcached-storage.Tpo -c -o memcached-storage.obj `if test -f 'storage.c'; then $(CYGPATH_W) 'storage.c'; else $(CYGPATH_W) '$(srcdir)/storage.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-storage.Tpo $(DEPDIR)/memcached-storage.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='storage.c' object='memcached-storage.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-storage.obj `if test -f 'storage.c'; then $(CYGPATH_W) 'storage.c'; else $(CYGPATH_W) '$(srcdir)/storage.c'; fi` memcached-slab_automove_extstore.o: slab_automove_extstore.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-slab_automove_extstore.o -MD -MP -MF $(DEPDIR)/memcached-slab_automove_extstore.Tpo -c -o memcached-slab_automove_extstore.o `test -f 'slab_automove_extstore.c' || echo '$(srcdir)/'`slab_automove_extstore.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-slab_automove_extstore.Tpo $(DEPDIR)/memcached-slab_automove_extstore.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slab_automove_extstore.c' object='memcached-slab_automove_extstore.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-slab_automove_extstore.o `test -f 'slab_automove_extstore.c' || echo '$(srcdir)/'`slab_automove_extstore.c memcached-slab_automove_extstore.obj: slab_automove_extstore.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-slab_automove_extstore.obj -MD -MP -MF $(DEPDIR)/memcached-slab_automove_extstore.Tpo -c -o memcached-slab_automove_extstore.obj `if test -f 'slab_automove_extstore.c'; then $(CYGPATH_W) 'slab_automove_extstore.c'; else $(CYGPATH_W) '$(srcdir)/slab_automove_extstore.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-slab_automove_extstore.Tpo $(DEPDIR)/memcached-slab_automove_extstore.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slab_automove_extstore.c' object='memcached-slab_automove_extstore.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-slab_automove_extstore.obj `if test -f 'slab_automove_extstore.c'; then $(CYGPATH_W) 'slab_automove_extstore.c'; else $(CYGPATH_W) '$(srcdir)/slab_automove_extstore.c'; fi` memcached-tls.o: tls.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-tls.o -MD -MP -MF $(DEPDIR)/memcached-tls.Tpo -c -o memcached-tls.o `test -f 'tls.c' || echo '$(srcdir)/'`tls.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-tls.Tpo $(DEPDIR)/memcached-tls.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='tls.c' object='memcached-tls.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-tls.o `test -f 'tls.c' || echo '$(srcdir)/'`tls.c memcached-tls.obj: tls.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT memcached-tls.obj -MD -MP -MF $(DEPDIR)/memcached-tls.Tpo -c -o memcached-tls.obj `if test -f 'tls.c'; then $(CYGPATH_W) 'tls.c'; else $(CYGPATH_W) '$(srcdir)/tls.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached-tls.Tpo $(DEPDIR)/memcached-tls.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='tls.c' object='memcached-tls.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(memcached_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o memcached-tls.obj `if test -f 'tls.c'; then $(CYGPATH_W) 'tls.c'; else $(CYGPATH_W) '$(srcdir)/tls.c'; fi` memcached_debug-memcached.o: memcached.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-memcached.o -MD -MP -MF $(DEPDIR)/memcached_debug-memcached.Tpo -c -o memcached_debug-memcached.o `test -f 'memcached.c' || echo '$(srcdir)/'`memcached.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-memcached.Tpo $(DEPDIR)/memcached_debug-memcached.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='memcached.c' object='memcached_debug-memcached.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-memcached.o `test -f 'memcached.c' || echo '$(srcdir)/'`memcached.c memcached_debug-memcached.obj: memcached.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-memcached.obj -MD -MP -MF $(DEPDIR)/memcached_debug-memcached.Tpo -c -o memcached_debug-memcached.obj `if test -f 'memcached.c'; then $(CYGPATH_W) 'memcached.c'; else $(CYGPATH_W) '$(srcdir)/memcached.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-memcached.Tpo $(DEPDIR)/memcached_debug-memcached.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='memcached.c' object='memcached_debug-memcached.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-memcached.obj `if test -f 'memcached.c'; then $(CYGPATH_W) 'memcached.c'; else $(CYGPATH_W) '$(srcdir)/memcached.c'; fi` memcached_debug-hash.o: hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-hash.o -MD -MP -MF $(DEPDIR)/memcached_debug-hash.Tpo -c -o memcached_debug-hash.o `test -f 'hash.c' || echo '$(srcdir)/'`hash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-hash.Tpo $(DEPDIR)/memcached_debug-hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='hash.c' object='memcached_debug-hash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-hash.o `test -f 'hash.c' || echo '$(srcdir)/'`hash.c memcached_debug-hash.obj: hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-hash.obj -MD -MP -MF $(DEPDIR)/memcached_debug-hash.Tpo -c -o memcached_debug-hash.obj `if test -f 'hash.c'; then $(CYGPATH_W) 'hash.c'; else $(CYGPATH_W) '$(srcdir)/hash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-hash.Tpo $(DEPDIR)/memcached_debug-hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='hash.c' object='memcached_debug-hash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-hash.obj `if test -f 'hash.c'; then $(CYGPATH_W) 'hash.c'; else $(CYGPATH_W) '$(srcdir)/hash.c'; fi` memcached_debug-jenkins_hash.o: jenkins_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-jenkins_hash.o -MD -MP -MF $(DEPDIR)/memcached_debug-jenkins_hash.Tpo -c -o memcached_debug-jenkins_hash.o `test -f 'jenkins_hash.c' || echo '$(srcdir)/'`jenkins_hash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-jenkins_hash.Tpo $(DEPDIR)/memcached_debug-jenkins_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='jenkins_hash.c' object='memcached_debug-jenkins_hash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-jenkins_hash.o `test -f 'jenkins_hash.c' || echo '$(srcdir)/'`jenkins_hash.c memcached_debug-jenkins_hash.obj: jenkins_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-jenkins_hash.obj -MD -MP -MF $(DEPDIR)/memcached_debug-jenkins_hash.Tpo -c -o memcached_debug-jenkins_hash.obj `if test -f 'jenkins_hash.c'; then $(CYGPATH_W) 'jenkins_hash.c'; else $(CYGPATH_W) '$(srcdir)/jenkins_hash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-jenkins_hash.Tpo $(DEPDIR)/memcached_debug-jenkins_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='jenkins_hash.c' object='memcached_debug-jenkins_hash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-jenkins_hash.obj `if test -f 'jenkins_hash.c'; then $(CYGPATH_W) 'jenkins_hash.c'; else $(CYGPATH_W) '$(srcdir)/jenkins_hash.c'; fi` memcached_debug-murmur3_hash.o: murmur3_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-murmur3_hash.o -MD -MP -MF $(DEPDIR)/memcached_debug-murmur3_hash.Tpo -c -o memcached_debug-murmur3_hash.o `test -f 'murmur3_hash.c' || echo '$(srcdir)/'`murmur3_hash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-murmur3_hash.Tpo $(DEPDIR)/memcached_debug-murmur3_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='murmur3_hash.c' object='memcached_debug-murmur3_hash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-murmur3_hash.o `test -f 'murmur3_hash.c' || echo '$(srcdir)/'`murmur3_hash.c memcached_debug-murmur3_hash.obj: murmur3_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-murmur3_hash.obj -MD -MP -MF $(DEPDIR)/memcached_debug-murmur3_hash.Tpo -c -o memcached_debug-murmur3_hash.obj `if test -f 'murmur3_hash.c'; then $(CYGPATH_W) 'murmur3_hash.c'; else $(CYGPATH_W) '$(srcdir)/murmur3_hash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-murmur3_hash.Tpo $(DEPDIR)/memcached_debug-murmur3_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='murmur3_hash.c' object='memcached_debug-murmur3_hash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-murmur3_hash.obj `if test -f 'murmur3_hash.c'; then $(CYGPATH_W) 'murmur3_hash.c'; else $(CYGPATH_W) '$(srcdir)/murmur3_hash.c'; fi` memcached_debug-slabs.o: slabs.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-slabs.o -MD -MP -MF $(DEPDIR)/memcached_debug-slabs.Tpo -c -o memcached_debug-slabs.o `test -f 'slabs.c' || echo '$(srcdir)/'`slabs.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-slabs.Tpo $(DEPDIR)/memcached_debug-slabs.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slabs.c' object='memcached_debug-slabs.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-slabs.o `test -f 'slabs.c' || echo '$(srcdir)/'`slabs.c memcached_debug-slabs.obj: slabs.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-slabs.obj -MD -MP -MF $(DEPDIR)/memcached_debug-slabs.Tpo -c -o memcached_debug-slabs.obj `if test -f 'slabs.c'; then $(CYGPATH_W) 'slabs.c'; else $(CYGPATH_W) '$(srcdir)/slabs.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-slabs.Tpo $(DEPDIR)/memcached_debug-slabs.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slabs.c' object='memcached_debug-slabs.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-slabs.obj `if test -f 'slabs.c'; then $(CYGPATH_W) 'slabs.c'; else $(CYGPATH_W) '$(srcdir)/slabs.c'; fi` memcached_debug-items.o: items.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-items.o -MD -MP -MF $(DEPDIR)/memcached_debug-items.Tpo -c -o memcached_debug-items.o `test -f 'items.c' || echo '$(srcdir)/'`items.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-items.Tpo $(DEPDIR)/memcached_debug-items.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='items.c' object='memcached_debug-items.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-items.o `test -f 'items.c' || echo '$(srcdir)/'`items.c memcached_debug-items.obj: items.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-items.obj -MD -MP -MF $(DEPDIR)/memcached_debug-items.Tpo -c -o memcached_debug-items.obj `if test -f 'items.c'; then $(CYGPATH_W) 'items.c'; else $(CYGPATH_W) '$(srcdir)/items.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-items.Tpo $(DEPDIR)/memcached_debug-items.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='items.c' object='memcached_debug-items.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-items.obj `if test -f 'items.c'; then $(CYGPATH_W) 'items.c'; else $(CYGPATH_W) '$(srcdir)/items.c'; fi` memcached_debug-assoc.o: assoc.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-assoc.o -MD -MP -MF $(DEPDIR)/memcached_debug-assoc.Tpo -c -o memcached_debug-assoc.o `test -f 'assoc.c' || echo '$(srcdir)/'`assoc.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-assoc.Tpo $(DEPDIR)/memcached_debug-assoc.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assoc.c' object='memcached_debug-assoc.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-assoc.o `test -f 'assoc.c' || echo '$(srcdir)/'`assoc.c memcached_debug-assoc.obj: assoc.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-assoc.obj -MD -MP -MF $(DEPDIR)/memcached_debug-assoc.Tpo -c -o memcached_debug-assoc.obj `if test -f 'assoc.c'; then $(CYGPATH_W) 'assoc.c'; else $(CYGPATH_W) '$(srcdir)/assoc.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-assoc.Tpo $(DEPDIR)/memcached_debug-assoc.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assoc.c' object='memcached_debug-assoc.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-assoc.obj `if test -f 'assoc.c'; then $(CYGPATH_W) 'assoc.c'; else $(CYGPATH_W) '$(srcdir)/assoc.c'; fi` memcached_debug-thread.o: thread.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-thread.o -MD -MP -MF $(DEPDIR)/memcached_debug-thread.Tpo -c -o memcached_debug-thread.o `test -f 'thread.c' || echo '$(srcdir)/'`thread.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-thread.Tpo $(DEPDIR)/memcached_debug-thread.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='thread.c' object='memcached_debug-thread.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-thread.o `test -f 'thread.c' || echo '$(srcdir)/'`thread.c memcached_debug-thread.obj: thread.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-thread.obj -MD -MP -MF $(DEPDIR)/memcached_debug-thread.Tpo -c -o memcached_debug-thread.obj `if test -f 'thread.c'; then $(CYGPATH_W) 'thread.c'; else $(CYGPATH_W) '$(srcdir)/thread.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-thread.Tpo $(DEPDIR)/memcached_debug-thread.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='thread.c' object='memcached_debug-thread.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-thread.obj `if test -f 'thread.c'; then $(CYGPATH_W) 'thread.c'; else $(CYGPATH_W) '$(srcdir)/thread.c'; fi` memcached_debug-daemon.o: daemon.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-daemon.o -MD -MP -MF $(DEPDIR)/memcached_debug-daemon.Tpo -c -o memcached_debug-daemon.o `test -f 'daemon.c' || echo '$(srcdir)/'`daemon.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-daemon.Tpo $(DEPDIR)/memcached_debug-daemon.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='daemon.c' object='memcached_debug-daemon.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-daemon.o `test -f 'daemon.c' || echo '$(srcdir)/'`daemon.c memcached_debug-daemon.obj: daemon.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-daemon.obj -MD -MP -MF $(DEPDIR)/memcached_debug-daemon.Tpo -c -o memcached_debug-daemon.obj `if test -f 'daemon.c'; then $(CYGPATH_W) 'daemon.c'; else $(CYGPATH_W) '$(srcdir)/daemon.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-daemon.Tpo $(DEPDIR)/memcached_debug-daemon.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='daemon.c' object='memcached_debug-daemon.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-daemon.obj `if test -f 'daemon.c'; then $(CYGPATH_W) 'daemon.c'; else $(CYGPATH_W) '$(srcdir)/daemon.c'; fi` memcached_debug-stats_prefix.o: stats_prefix.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-stats_prefix.o -MD -MP -MF $(DEPDIR)/memcached_debug-stats_prefix.Tpo -c -o memcached_debug-stats_prefix.o `test -f 'stats_prefix.c' || echo '$(srcdir)/'`stats_prefix.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-stats_prefix.Tpo $(DEPDIR)/memcached_debug-stats_prefix.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='stats_prefix.c' object='memcached_debug-stats_prefix.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-stats_prefix.o `test -f 'stats_prefix.c' || echo '$(srcdir)/'`stats_prefix.c memcached_debug-stats_prefix.obj: stats_prefix.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-stats_prefix.obj -MD -MP -MF $(DEPDIR)/memcached_debug-stats_prefix.Tpo -c -o memcached_debug-stats_prefix.obj `if test -f 'stats_prefix.c'; then $(CYGPATH_W) 'stats_prefix.c'; else $(CYGPATH_W) '$(srcdir)/stats_prefix.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-stats_prefix.Tpo $(DEPDIR)/memcached_debug-stats_prefix.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='stats_prefix.c' object='memcached_debug-stats_prefix.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-stats_prefix.obj `if test -f 'stats_prefix.c'; then $(CYGPATH_W) 'stats_prefix.c'; else $(CYGPATH_W) '$(srcdir)/stats_prefix.c'; fi` memcached_debug-util.o: util.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-util.o -MD -MP -MF $(DEPDIR)/memcached_debug-util.Tpo -c -o memcached_debug-util.o `test -f 'util.c' || echo '$(srcdir)/'`util.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-util.Tpo $(DEPDIR)/memcached_debug-util.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='util.c' object='memcached_debug-util.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-util.o `test -f 'util.c' || echo '$(srcdir)/'`util.c memcached_debug-util.obj: util.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-util.obj -MD -MP -MF $(DEPDIR)/memcached_debug-util.Tpo -c -o memcached_debug-util.obj `if test -f 'util.c'; then $(CYGPATH_W) 'util.c'; else $(CYGPATH_W) '$(srcdir)/util.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-util.Tpo $(DEPDIR)/memcached_debug-util.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='util.c' object='memcached_debug-util.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-util.obj `if test -f 'util.c'; then $(CYGPATH_W) 'util.c'; else $(CYGPATH_W) '$(srcdir)/util.c'; fi` memcached_debug-cache.o: cache.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-cache.o -MD -MP -MF $(DEPDIR)/memcached_debug-cache.Tpo -c -o memcached_debug-cache.o `test -f 'cache.c' || echo '$(srcdir)/'`cache.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-cache.Tpo $(DEPDIR)/memcached_debug-cache.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='cache.c' object='memcached_debug-cache.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-cache.o `test -f 'cache.c' || echo '$(srcdir)/'`cache.c memcached_debug-cache.obj: cache.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-cache.obj -MD -MP -MF $(DEPDIR)/memcached_debug-cache.Tpo -c -o memcached_debug-cache.obj `if test -f 'cache.c'; then $(CYGPATH_W) 'cache.c'; else $(CYGPATH_W) '$(srcdir)/cache.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-cache.Tpo $(DEPDIR)/memcached_debug-cache.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='cache.c' object='memcached_debug-cache.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-cache.obj `if test -f 'cache.c'; then $(CYGPATH_W) 'cache.c'; else $(CYGPATH_W) '$(srcdir)/cache.c'; fi` memcached_debug-bipbuffer.o: bipbuffer.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-bipbuffer.o -MD -MP -MF $(DEPDIR)/memcached_debug-bipbuffer.Tpo -c -o memcached_debug-bipbuffer.o `test -f 'bipbuffer.c' || echo '$(srcdir)/'`bipbuffer.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-bipbuffer.Tpo $(DEPDIR)/memcached_debug-bipbuffer.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='bipbuffer.c' object='memcached_debug-bipbuffer.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-bipbuffer.o `test -f 'bipbuffer.c' || echo '$(srcdir)/'`bipbuffer.c memcached_debug-bipbuffer.obj: bipbuffer.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-bipbuffer.obj -MD -MP -MF $(DEPDIR)/memcached_debug-bipbuffer.Tpo -c -o memcached_debug-bipbuffer.obj `if test -f 'bipbuffer.c'; then $(CYGPATH_W) 'bipbuffer.c'; else $(CYGPATH_W) '$(srcdir)/bipbuffer.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-bipbuffer.Tpo $(DEPDIR)/memcached_debug-bipbuffer.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='bipbuffer.c' object='memcached_debug-bipbuffer.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-bipbuffer.obj `if test -f 'bipbuffer.c'; then $(CYGPATH_W) 'bipbuffer.c'; else $(CYGPATH_W) '$(srcdir)/bipbuffer.c'; fi` memcached_debug-base64.o: base64.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-base64.o -MD -MP -MF $(DEPDIR)/memcached_debug-base64.Tpo -c -o memcached_debug-base64.o `test -f 'base64.c' || echo '$(srcdir)/'`base64.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-base64.Tpo $(DEPDIR)/memcached_debug-base64.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='base64.c' object='memcached_debug-base64.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-base64.o `test -f 'base64.c' || echo '$(srcdir)/'`base64.c memcached_debug-base64.obj: base64.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-base64.obj -MD -MP -MF $(DEPDIR)/memcached_debug-base64.Tpo -c -o memcached_debug-base64.obj `if test -f 'base64.c'; then $(CYGPATH_W) 'base64.c'; else $(CYGPATH_W) '$(srcdir)/base64.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-base64.Tpo $(DEPDIR)/memcached_debug-base64.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='base64.c' object='memcached_debug-base64.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-base64.obj `if test -f 'base64.c'; then $(CYGPATH_W) 'base64.c'; else $(CYGPATH_W) '$(srcdir)/base64.c'; fi` memcached_debug-logger.o: logger.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-logger.o -MD -MP -MF $(DEPDIR)/memcached_debug-logger.Tpo -c -o memcached_debug-logger.o `test -f 'logger.c' || echo '$(srcdir)/'`logger.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-logger.Tpo $(DEPDIR)/memcached_debug-logger.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='logger.c' object='memcached_debug-logger.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-logger.o `test -f 'logger.c' || echo '$(srcdir)/'`logger.c memcached_debug-logger.obj: logger.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-logger.obj -MD -MP -MF $(DEPDIR)/memcached_debug-logger.Tpo -c -o memcached_debug-logger.obj `if test -f 'logger.c'; then $(CYGPATH_W) 'logger.c'; else $(CYGPATH_W) '$(srcdir)/logger.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-logger.Tpo $(DEPDIR)/memcached_debug-logger.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='logger.c' object='memcached_debug-logger.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-logger.obj `if test -f 'logger.c'; then $(CYGPATH_W) 'logger.c'; else $(CYGPATH_W) '$(srcdir)/logger.c'; fi` memcached_debug-crawler.o: crawler.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-crawler.o -MD -MP -MF $(DEPDIR)/memcached_debug-crawler.Tpo -c -o memcached_debug-crawler.o `test -f 'crawler.c' || echo '$(srcdir)/'`crawler.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-crawler.Tpo $(DEPDIR)/memcached_debug-crawler.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='crawler.c' object='memcached_debug-crawler.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-crawler.o `test -f 'crawler.c' || echo '$(srcdir)/'`crawler.c memcached_debug-crawler.obj: crawler.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-crawler.obj -MD -MP -MF $(DEPDIR)/memcached_debug-crawler.Tpo -c -o memcached_debug-crawler.obj `if test -f 'crawler.c'; then $(CYGPATH_W) 'crawler.c'; else $(CYGPATH_W) '$(srcdir)/crawler.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-crawler.Tpo $(DEPDIR)/memcached_debug-crawler.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='crawler.c' object='memcached_debug-crawler.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-crawler.obj `if test -f 'crawler.c'; then $(CYGPATH_W) 'crawler.c'; else $(CYGPATH_W) '$(srcdir)/crawler.c'; fi` memcached_debug-itoa_ljust.o: itoa_ljust.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-itoa_ljust.o -MD -MP -MF $(DEPDIR)/memcached_debug-itoa_ljust.Tpo -c -o memcached_debug-itoa_ljust.o `test -f 'itoa_ljust.c' || echo '$(srcdir)/'`itoa_ljust.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-itoa_ljust.Tpo $(DEPDIR)/memcached_debug-itoa_ljust.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='itoa_ljust.c' object='memcached_debug-itoa_ljust.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-itoa_ljust.o `test -f 'itoa_ljust.c' || echo '$(srcdir)/'`itoa_ljust.c memcached_debug-itoa_ljust.obj: itoa_ljust.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-itoa_ljust.obj -MD -MP -MF $(DEPDIR)/memcached_debug-itoa_ljust.Tpo -c -o memcached_debug-itoa_ljust.obj `if test -f 'itoa_ljust.c'; then $(CYGPATH_W) 'itoa_ljust.c'; else $(CYGPATH_W) '$(srcdir)/itoa_ljust.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-itoa_ljust.Tpo $(DEPDIR)/memcached_debug-itoa_ljust.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='itoa_ljust.c' object='memcached_debug-itoa_ljust.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-itoa_ljust.obj `if test -f 'itoa_ljust.c'; then $(CYGPATH_W) 'itoa_ljust.c'; else $(CYGPATH_W) '$(srcdir)/itoa_ljust.c'; fi` memcached_debug-slab_automove.o: slab_automove.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-slab_automove.o -MD -MP -MF $(DEPDIR)/memcached_debug-slab_automove.Tpo -c -o memcached_debug-slab_automove.o `test -f 'slab_automove.c' || echo '$(srcdir)/'`slab_automove.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-slab_automove.Tpo $(DEPDIR)/memcached_debug-slab_automove.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slab_automove.c' object='memcached_debug-slab_automove.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-slab_automove.o `test -f 'slab_automove.c' || echo '$(srcdir)/'`slab_automove.c memcached_debug-slab_automove.obj: slab_automove.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-slab_automove.obj -MD -MP -MF $(DEPDIR)/memcached_debug-slab_automove.Tpo -c -o memcached_debug-slab_automove.obj `if test -f 'slab_automove.c'; then $(CYGPATH_W) 'slab_automove.c'; else $(CYGPATH_W) '$(srcdir)/slab_automove.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-slab_automove.Tpo $(DEPDIR)/memcached_debug-slab_automove.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slab_automove.c' object='memcached_debug-slab_automove.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-slab_automove.obj `if test -f 'slab_automove.c'; then $(CYGPATH_W) 'slab_automove.c'; else $(CYGPATH_W) '$(srcdir)/slab_automove.c'; fi` memcached_debug-authfile.o: authfile.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-authfile.o -MD -MP -MF $(DEPDIR)/memcached_debug-authfile.Tpo -c -o memcached_debug-authfile.o `test -f 'authfile.c' || echo '$(srcdir)/'`authfile.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-authfile.Tpo $(DEPDIR)/memcached_debug-authfile.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='authfile.c' object='memcached_debug-authfile.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-authfile.o `test -f 'authfile.c' || echo '$(srcdir)/'`authfile.c memcached_debug-authfile.obj: authfile.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-authfile.obj -MD -MP -MF $(DEPDIR)/memcached_debug-authfile.Tpo -c -o memcached_debug-authfile.obj `if test -f 'authfile.c'; then $(CYGPATH_W) 'authfile.c'; else $(CYGPATH_W) '$(srcdir)/authfile.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-authfile.Tpo $(DEPDIR)/memcached_debug-authfile.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='authfile.c' object='memcached_debug-authfile.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-authfile.obj `if test -f 'authfile.c'; then $(CYGPATH_W) 'authfile.c'; else $(CYGPATH_W) '$(srcdir)/authfile.c'; fi` memcached_debug-restart.o: restart.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-restart.o -MD -MP -MF $(DEPDIR)/memcached_debug-restart.Tpo -c -o memcached_debug-restart.o `test -f 'restart.c' || echo '$(srcdir)/'`restart.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-restart.Tpo $(DEPDIR)/memcached_debug-restart.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='restart.c' object='memcached_debug-restart.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-restart.o `test -f 'restart.c' || echo '$(srcdir)/'`restart.c memcached_debug-restart.obj: restart.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-restart.obj -MD -MP -MF $(DEPDIR)/memcached_debug-restart.Tpo -c -o memcached_debug-restart.obj `if test -f 'restart.c'; then $(CYGPATH_W) 'restart.c'; else $(CYGPATH_W) '$(srcdir)/restart.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-restart.Tpo $(DEPDIR)/memcached_debug-restart.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='restart.c' object='memcached_debug-restart.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-restart.obj `if test -f 'restart.c'; then $(CYGPATH_W) 'restart.c'; else $(CYGPATH_W) '$(srcdir)/restart.c'; fi` memcached_debug-proto_text.o: proto_text.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proto_text.o -MD -MP -MF $(DEPDIR)/memcached_debug-proto_text.Tpo -c -o memcached_debug-proto_text.o `test -f 'proto_text.c' || echo '$(srcdir)/'`proto_text.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proto_text.Tpo $(DEPDIR)/memcached_debug-proto_text.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_text.c' object='memcached_debug-proto_text.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proto_text.o `test -f 'proto_text.c' || echo '$(srcdir)/'`proto_text.c memcached_debug-proto_text.obj: proto_text.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proto_text.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proto_text.Tpo -c -o memcached_debug-proto_text.obj `if test -f 'proto_text.c'; then $(CYGPATH_W) 'proto_text.c'; else $(CYGPATH_W) '$(srcdir)/proto_text.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proto_text.Tpo $(DEPDIR)/memcached_debug-proto_text.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_text.c' object='memcached_debug-proto_text.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proto_text.obj `if test -f 'proto_text.c'; then $(CYGPATH_W) 'proto_text.c'; else $(CYGPATH_W) '$(srcdir)/proto_text.c'; fi` memcached_debug-proto_bin.o: proto_bin.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proto_bin.o -MD -MP -MF $(DEPDIR)/memcached_debug-proto_bin.Tpo -c -o memcached_debug-proto_bin.o `test -f 'proto_bin.c' || echo '$(srcdir)/'`proto_bin.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proto_bin.Tpo $(DEPDIR)/memcached_debug-proto_bin.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_bin.c' object='memcached_debug-proto_bin.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proto_bin.o `test -f 'proto_bin.c' || echo '$(srcdir)/'`proto_bin.c memcached_debug-proto_bin.obj: proto_bin.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proto_bin.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proto_bin.Tpo -c -o memcached_debug-proto_bin.obj `if test -f 'proto_bin.c'; then $(CYGPATH_W) 'proto_bin.c'; else $(CYGPATH_W) '$(srcdir)/proto_bin.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proto_bin.Tpo $(DEPDIR)/memcached_debug-proto_bin.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_bin.c' object='memcached_debug-proto_bin.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proto_bin.obj `if test -f 'proto_bin.c'; then $(CYGPATH_W) 'proto_bin.c'; else $(CYGPATH_W) '$(srcdir)/proto_bin.c'; fi` memcached_debug-solaris_priv.o: solaris_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-solaris_priv.o -MD -MP -MF $(DEPDIR)/memcached_debug-solaris_priv.Tpo -c -o memcached_debug-solaris_priv.o `test -f 'solaris_priv.c' || echo '$(srcdir)/'`solaris_priv.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-solaris_priv.Tpo $(DEPDIR)/memcached_debug-solaris_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='solaris_priv.c' object='memcached_debug-solaris_priv.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-solaris_priv.o `test -f 'solaris_priv.c' || echo '$(srcdir)/'`solaris_priv.c memcached_debug-solaris_priv.obj: solaris_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-solaris_priv.obj -MD -MP -MF $(DEPDIR)/memcached_debug-solaris_priv.Tpo -c -o memcached_debug-solaris_priv.obj `if test -f 'solaris_priv.c'; then $(CYGPATH_W) 'solaris_priv.c'; else $(CYGPATH_W) '$(srcdir)/solaris_priv.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-solaris_priv.Tpo $(DEPDIR)/memcached_debug-solaris_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='solaris_priv.c' object='memcached_debug-solaris_priv.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-solaris_priv.obj `if test -f 'solaris_priv.c'; then $(CYGPATH_W) 'solaris_priv.c'; else $(CYGPATH_W) '$(srcdir)/solaris_priv.c'; fi` memcached_debug-linux_priv.o: linux_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-linux_priv.o -MD -MP -MF $(DEPDIR)/memcached_debug-linux_priv.Tpo -c -o memcached_debug-linux_priv.o `test -f 'linux_priv.c' || echo '$(srcdir)/'`linux_priv.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-linux_priv.Tpo $(DEPDIR)/memcached_debug-linux_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='linux_priv.c' object='memcached_debug-linux_priv.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-linux_priv.o `test -f 'linux_priv.c' || echo '$(srcdir)/'`linux_priv.c memcached_debug-linux_priv.obj: linux_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-linux_priv.obj -MD -MP -MF $(DEPDIR)/memcached_debug-linux_priv.Tpo -c -o memcached_debug-linux_priv.obj `if test -f 'linux_priv.c'; then $(CYGPATH_W) 'linux_priv.c'; else $(CYGPATH_W) '$(srcdir)/linux_priv.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-linux_priv.Tpo $(DEPDIR)/memcached_debug-linux_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='linux_priv.c' object='memcached_debug-linux_priv.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-linux_priv.obj `if test -f 'linux_priv.c'; then $(CYGPATH_W) 'linux_priv.c'; else $(CYGPATH_W) '$(srcdir)/linux_priv.c'; fi` memcached_debug-openbsd_priv.o: openbsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-openbsd_priv.o -MD -MP -MF $(DEPDIR)/memcached_debug-openbsd_priv.Tpo -c -o memcached_debug-openbsd_priv.o `test -f 'openbsd_priv.c' || echo '$(srcdir)/'`openbsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-openbsd_priv.Tpo $(DEPDIR)/memcached_debug-openbsd_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='openbsd_priv.c' object='memcached_debug-openbsd_priv.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-openbsd_priv.o `test -f 'openbsd_priv.c' || echo '$(srcdir)/'`openbsd_priv.c memcached_debug-openbsd_priv.obj: openbsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-openbsd_priv.obj -MD -MP -MF $(DEPDIR)/memcached_debug-openbsd_priv.Tpo -c -o memcached_debug-openbsd_priv.obj `if test -f 'openbsd_priv.c'; then $(CYGPATH_W) 'openbsd_priv.c'; else $(CYGPATH_W) '$(srcdir)/openbsd_priv.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-openbsd_priv.Tpo $(DEPDIR)/memcached_debug-openbsd_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='openbsd_priv.c' object='memcached_debug-openbsd_priv.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-openbsd_priv.obj `if test -f 'openbsd_priv.c'; then $(CYGPATH_W) 'openbsd_priv.c'; else $(CYGPATH_W) '$(srcdir)/openbsd_priv.c'; fi` memcached_debug-freebsd_priv.o: freebsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-freebsd_priv.o -MD -MP -MF $(DEPDIR)/memcached_debug-freebsd_priv.Tpo -c -o memcached_debug-freebsd_priv.o `test -f 'freebsd_priv.c' || echo '$(srcdir)/'`freebsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-freebsd_priv.Tpo $(DEPDIR)/memcached_debug-freebsd_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='freebsd_priv.c' object='memcached_debug-freebsd_priv.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-freebsd_priv.o `test -f 'freebsd_priv.c' || echo '$(srcdir)/'`freebsd_priv.c memcached_debug-freebsd_priv.obj: freebsd_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-freebsd_priv.obj -MD -MP -MF $(DEPDIR)/memcached_debug-freebsd_priv.Tpo -c -o memcached_debug-freebsd_priv.obj `if test -f 'freebsd_priv.c'; then $(CYGPATH_W) 'freebsd_priv.c'; else $(CYGPATH_W) '$(srcdir)/freebsd_priv.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-freebsd_priv.Tpo $(DEPDIR)/memcached_debug-freebsd_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='freebsd_priv.c' object='memcached_debug-freebsd_priv.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-freebsd_priv.obj `if test -f 'freebsd_priv.c'; then $(CYGPATH_W) 'freebsd_priv.c'; else $(CYGPATH_W) '$(srcdir)/freebsd_priv.c'; fi` memcached_debug-darwin_priv.o: darwin_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-darwin_priv.o -MD -MP -MF $(DEPDIR)/memcached_debug-darwin_priv.Tpo -c -o memcached_debug-darwin_priv.o `test -f 'darwin_priv.c' || echo '$(srcdir)/'`darwin_priv.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-darwin_priv.Tpo $(DEPDIR)/memcached_debug-darwin_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='darwin_priv.c' object='memcached_debug-darwin_priv.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-darwin_priv.o `test -f 'darwin_priv.c' || echo '$(srcdir)/'`darwin_priv.c memcached_debug-darwin_priv.obj: darwin_priv.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-darwin_priv.obj -MD -MP -MF $(DEPDIR)/memcached_debug-darwin_priv.Tpo -c -o memcached_debug-darwin_priv.obj `if test -f 'darwin_priv.c'; then $(CYGPATH_W) 'darwin_priv.c'; else $(CYGPATH_W) '$(srcdir)/darwin_priv.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-darwin_priv.Tpo $(DEPDIR)/memcached_debug-darwin_priv.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='darwin_priv.c' object='memcached_debug-darwin_priv.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-darwin_priv.obj `if test -f 'darwin_priv.c'; then $(CYGPATH_W) 'darwin_priv.c'; else $(CYGPATH_W) '$(srcdir)/darwin_priv.c'; fi` memcached_debug-sasl_defs.o: sasl_defs.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-sasl_defs.o -MD -MP -MF $(DEPDIR)/memcached_debug-sasl_defs.Tpo -c -o memcached_debug-sasl_defs.o `test -f 'sasl_defs.c' || echo '$(srcdir)/'`sasl_defs.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-sasl_defs.Tpo $(DEPDIR)/memcached_debug-sasl_defs.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='sasl_defs.c' object='memcached_debug-sasl_defs.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-sasl_defs.o `test -f 'sasl_defs.c' || echo '$(srcdir)/'`sasl_defs.c memcached_debug-sasl_defs.obj: sasl_defs.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-sasl_defs.obj -MD -MP -MF $(DEPDIR)/memcached_debug-sasl_defs.Tpo -c -o memcached_debug-sasl_defs.obj `if test -f 'sasl_defs.c'; then $(CYGPATH_W) 'sasl_defs.c'; else $(CYGPATH_W) '$(srcdir)/sasl_defs.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-sasl_defs.Tpo $(DEPDIR)/memcached_debug-sasl_defs.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='sasl_defs.c' object='memcached_debug-sasl_defs.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-sasl_defs.obj `if test -f 'sasl_defs.c'; then $(CYGPATH_W) 'sasl_defs.c'; else $(CYGPATH_W) '$(srcdir)/sasl_defs.c'; fi` memcached_debug-proto_proxy.o: proto_proxy.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proto_proxy.o -MD -MP -MF $(DEPDIR)/memcached_debug-proto_proxy.Tpo -c -o memcached_debug-proto_proxy.o `test -f 'proto_proxy.c' || echo '$(srcdir)/'`proto_proxy.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proto_proxy.Tpo $(DEPDIR)/memcached_debug-proto_proxy.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_proxy.c' object='memcached_debug-proto_proxy.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proto_proxy.o `test -f 'proto_proxy.c' || echo '$(srcdir)/'`proto_proxy.c memcached_debug-proto_proxy.obj: proto_proxy.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proto_proxy.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proto_proxy.Tpo -c -o memcached_debug-proto_proxy.obj `if test -f 'proto_proxy.c'; then $(CYGPATH_W) 'proto_proxy.c'; else $(CYGPATH_W) '$(srcdir)/proto_proxy.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proto_proxy.Tpo $(DEPDIR)/memcached_debug-proto_proxy.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proto_proxy.c' object='memcached_debug-proto_proxy.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proto_proxy.obj `if test -f 'proto_proxy.c'; then $(CYGPATH_W) 'proto_proxy.c'; else $(CYGPATH_W) '$(srcdir)/proto_proxy.c'; fi` memcached_debug-proxy_xxhash.o: proxy_xxhash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_xxhash.o -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_xxhash.Tpo -c -o memcached_debug-proxy_xxhash.o `test -f 'proxy_xxhash.c' || echo '$(srcdir)/'`proxy_xxhash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_xxhash.Tpo $(DEPDIR)/memcached_debug-proxy_xxhash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_xxhash.c' object='memcached_debug-proxy_xxhash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_xxhash.o `test -f 'proxy_xxhash.c' || echo '$(srcdir)/'`proxy_xxhash.c memcached_debug-proxy_xxhash.obj: proxy_xxhash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_xxhash.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_xxhash.Tpo -c -o memcached_debug-proxy_xxhash.obj `if test -f 'proxy_xxhash.c'; then $(CYGPATH_W) 'proxy_xxhash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_xxhash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_xxhash.Tpo $(DEPDIR)/memcached_debug-proxy_xxhash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_xxhash.c' object='memcached_debug-proxy_xxhash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_xxhash.obj `if test -f 'proxy_xxhash.c'; then $(CYGPATH_W) 'proxy_xxhash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_xxhash.c'; fi` memcached_debug-proxy_await.o: proxy_await.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_await.o -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_await.Tpo -c -o memcached_debug-proxy_await.o `test -f 'proxy_await.c' || echo '$(srcdir)/'`proxy_await.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_await.Tpo $(DEPDIR)/memcached_debug-proxy_await.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_await.c' object='memcached_debug-proxy_await.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_await.o `test -f 'proxy_await.c' || echo '$(srcdir)/'`proxy_await.c memcached_debug-proxy_await.obj: proxy_await.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_await.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_await.Tpo -c -o memcached_debug-proxy_await.obj `if test -f 'proxy_await.c'; then $(CYGPATH_W) 'proxy_await.c'; else $(CYGPATH_W) '$(srcdir)/proxy_await.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_await.Tpo $(DEPDIR)/memcached_debug-proxy_await.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_await.c' object='memcached_debug-proxy_await.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_await.obj `if test -f 'proxy_await.c'; then $(CYGPATH_W) 'proxy_await.c'; else $(CYGPATH_W) '$(srcdir)/proxy_await.c'; fi` memcached_debug-proxy_ustats.o: proxy_ustats.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_ustats.o -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_ustats.Tpo -c -o memcached_debug-proxy_ustats.o `test -f 'proxy_ustats.c' || echo '$(srcdir)/'`proxy_ustats.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_ustats.Tpo $(DEPDIR)/memcached_debug-proxy_ustats.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_ustats.c' object='memcached_debug-proxy_ustats.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_ustats.o `test -f 'proxy_ustats.c' || echo '$(srcdir)/'`proxy_ustats.c memcached_debug-proxy_ustats.obj: proxy_ustats.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_ustats.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_ustats.Tpo -c -o memcached_debug-proxy_ustats.obj `if test -f 'proxy_ustats.c'; then $(CYGPATH_W) 'proxy_ustats.c'; else $(CYGPATH_W) '$(srcdir)/proxy_ustats.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_ustats.Tpo $(DEPDIR)/memcached_debug-proxy_ustats.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_ustats.c' object='memcached_debug-proxy_ustats.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_ustats.obj `if test -f 'proxy_ustats.c'; then $(CYGPATH_W) 'proxy_ustats.c'; else $(CYGPATH_W) '$(srcdir)/proxy_ustats.c'; fi` memcached_debug-proxy_jump_hash.o: proxy_jump_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_jump_hash.o -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_jump_hash.Tpo -c -o memcached_debug-proxy_jump_hash.o `test -f 'proxy_jump_hash.c' || echo '$(srcdir)/'`proxy_jump_hash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_jump_hash.Tpo $(DEPDIR)/memcached_debug-proxy_jump_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_jump_hash.c' object='memcached_debug-proxy_jump_hash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_jump_hash.o `test -f 'proxy_jump_hash.c' || echo '$(srcdir)/'`proxy_jump_hash.c memcached_debug-proxy_jump_hash.obj: proxy_jump_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_jump_hash.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_jump_hash.Tpo -c -o memcached_debug-proxy_jump_hash.obj `if test -f 'proxy_jump_hash.c'; then $(CYGPATH_W) 'proxy_jump_hash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_jump_hash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_jump_hash.Tpo $(DEPDIR)/memcached_debug-proxy_jump_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_jump_hash.c' object='memcached_debug-proxy_jump_hash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_jump_hash.obj `if test -f 'proxy_jump_hash.c'; then $(CYGPATH_W) 'proxy_jump_hash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_jump_hash.c'; fi` memcached_debug-proxy_request.o: proxy_request.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_request.o -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_request.Tpo -c -o memcached_debug-proxy_request.o `test -f 'proxy_request.c' || echo '$(srcdir)/'`proxy_request.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_request.Tpo $(DEPDIR)/memcached_debug-proxy_request.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_request.c' object='memcached_debug-proxy_request.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_request.o `test -f 'proxy_request.c' || echo '$(srcdir)/'`proxy_request.c memcached_debug-proxy_request.obj: proxy_request.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_request.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_request.Tpo -c -o memcached_debug-proxy_request.obj `if test -f 'proxy_request.c'; then $(CYGPATH_W) 'proxy_request.c'; else $(CYGPATH_W) '$(srcdir)/proxy_request.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_request.Tpo $(DEPDIR)/memcached_debug-proxy_request.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_request.c' object='memcached_debug-proxy_request.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_request.obj `if test -f 'proxy_request.c'; then $(CYGPATH_W) 'proxy_request.c'; else $(CYGPATH_W) '$(srcdir)/proxy_request.c'; fi` memcached_debug-proxy_network.o: proxy_network.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_network.o -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_network.Tpo -c -o memcached_debug-proxy_network.o `test -f 'proxy_network.c' || echo '$(srcdir)/'`proxy_network.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_network.Tpo $(DEPDIR)/memcached_debug-proxy_network.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_network.c' object='memcached_debug-proxy_network.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_network.o `test -f 'proxy_network.c' || echo '$(srcdir)/'`proxy_network.c memcached_debug-proxy_network.obj: proxy_network.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_network.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_network.Tpo -c -o memcached_debug-proxy_network.obj `if test -f 'proxy_network.c'; then $(CYGPATH_W) 'proxy_network.c'; else $(CYGPATH_W) '$(srcdir)/proxy_network.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_network.Tpo $(DEPDIR)/memcached_debug-proxy_network.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_network.c' object='memcached_debug-proxy_network.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_network.obj `if test -f 'proxy_network.c'; then $(CYGPATH_W) 'proxy_network.c'; else $(CYGPATH_W) '$(srcdir)/proxy_network.c'; fi` memcached_debug-proxy_lua.o: proxy_lua.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_lua.o -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_lua.Tpo -c -o memcached_debug-proxy_lua.o `test -f 'proxy_lua.c' || echo '$(srcdir)/'`proxy_lua.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_lua.Tpo $(DEPDIR)/memcached_debug-proxy_lua.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_lua.c' object='memcached_debug-proxy_lua.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_lua.o `test -f 'proxy_lua.c' || echo '$(srcdir)/'`proxy_lua.c memcached_debug-proxy_lua.obj: proxy_lua.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_lua.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_lua.Tpo -c -o memcached_debug-proxy_lua.obj `if test -f 'proxy_lua.c'; then $(CYGPATH_W) 'proxy_lua.c'; else $(CYGPATH_W) '$(srcdir)/proxy_lua.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_lua.Tpo $(DEPDIR)/memcached_debug-proxy_lua.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_lua.c' object='memcached_debug-proxy_lua.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_lua.obj `if test -f 'proxy_lua.c'; then $(CYGPATH_W) 'proxy_lua.c'; else $(CYGPATH_W) '$(srcdir)/proxy_lua.c'; fi` memcached_debug-proxy_config.o: proxy_config.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_config.o -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_config.Tpo -c -o memcached_debug-proxy_config.o `test -f 'proxy_config.c' || echo '$(srcdir)/'`proxy_config.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_config.Tpo $(DEPDIR)/memcached_debug-proxy_config.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_config.c' object='memcached_debug-proxy_config.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_config.o `test -f 'proxy_config.c' || echo '$(srcdir)/'`proxy_config.c memcached_debug-proxy_config.obj: proxy_config.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_config.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_config.Tpo -c -o memcached_debug-proxy_config.obj `if test -f 'proxy_config.c'; then $(CYGPATH_W) 'proxy_config.c'; else $(CYGPATH_W) '$(srcdir)/proxy_config.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_config.Tpo $(DEPDIR)/memcached_debug-proxy_config.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_config.c' object='memcached_debug-proxy_config.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_config.obj `if test -f 'proxy_config.c'; then $(CYGPATH_W) 'proxy_config.c'; else $(CYGPATH_W) '$(srcdir)/proxy_config.c'; fi` memcached_debug-proxy_ring_hash.o: proxy_ring_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_ring_hash.o -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_ring_hash.Tpo -c -o memcached_debug-proxy_ring_hash.o `test -f 'proxy_ring_hash.c' || echo '$(srcdir)/'`proxy_ring_hash.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_ring_hash.Tpo $(DEPDIR)/memcached_debug-proxy_ring_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_ring_hash.c' object='memcached_debug-proxy_ring_hash.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_ring_hash.o `test -f 'proxy_ring_hash.c' || echo '$(srcdir)/'`proxy_ring_hash.c memcached_debug-proxy_ring_hash.obj: proxy_ring_hash.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_ring_hash.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_ring_hash.Tpo -c -o memcached_debug-proxy_ring_hash.obj `if test -f 'proxy_ring_hash.c'; then $(CYGPATH_W) 'proxy_ring_hash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_ring_hash.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_ring_hash.Tpo $(DEPDIR)/memcached_debug-proxy_ring_hash.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_ring_hash.c' object='memcached_debug-proxy_ring_hash.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_ring_hash.obj `if test -f 'proxy_ring_hash.c'; then $(CYGPATH_W) 'proxy_ring_hash.c'; else $(CYGPATH_W) '$(srcdir)/proxy_ring_hash.c'; fi` memcached_debug-proxy_internal.o: proxy_internal.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_internal.o -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_internal.Tpo -c -o memcached_debug-proxy_internal.o `test -f 'proxy_internal.c' || echo '$(srcdir)/'`proxy_internal.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_internal.Tpo $(DEPDIR)/memcached_debug-proxy_internal.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_internal.c' object='memcached_debug-proxy_internal.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_internal.o `test -f 'proxy_internal.c' || echo '$(srcdir)/'`proxy_internal.c memcached_debug-proxy_internal.obj: proxy_internal.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-proxy_internal.obj -MD -MP -MF $(DEPDIR)/memcached_debug-proxy_internal.Tpo -c -o memcached_debug-proxy_internal.obj `if test -f 'proxy_internal.c'; then $(CYGPATH_W) 'proxy_internal.c'; else $(CYGPATH_W) '$(srcdir)/proxy_internal.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-proxy_internal.Tpo $(DEPDIR)/memcached_debug-proxy_internal.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='proxy_internal.c' object='memcached_debug-proxy_internal.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-proxy_internal.obj `if test -f 'proxy_internal.c'; then $(CYGPATH_W) 'proxy_internal.c'; else $(CYGPATH_W) '$(srcdir)/proxy_internal.c'; fi` memcached_debug-md5.o: md5.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-md5.o -MD -MP -MF $(DEPDIR)/memcached_debug-md5.Tpo -c -o memcached_debug-md5.o `test -f 'md5.c' || echo '$(srcdir)/'`md5.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-md5.Tpo $(DEPDIR)/memcached_debug-md5.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='md5.c' object='memcached_debug-md5.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-md5.o `test -f 'md5.c' || echo '$(srcdir)/'`md5.c memcached_debug-md5.obj: md5.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-md5.obj -MD -MP -MF $(DEPDIR)/memcached_debug-md5.Tpo -c -o memcached_debug-md5.obj `if test -f 'md5.c'; then $(CYGPATH_W) 'md5.c'; else $(CYGPATH_W) '$(srcdir)/md5.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-md5.Tpo $(DEPDIR)/memcached_debug-md5.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='md5.c' object='memcached_debug-md5.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-md5.obj `if test -f 'md5.c'; then $(CYGPATH_W) 'md5.c'; else $(CYGPATH_W) '$(srcdir)/md5.c'; fi` memcached_debug-extstore.o: extstore.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-extstore.o -MD -MP -MF $(DEPDIR)/memcached_debug-extstore.Tpo -c -o memcached_debug-extstore.o `test -f 'extstore.c' || echo '$(srcdir)/'`extstore.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-extstore.Tpo $(DEPDIR)/memcached_debug-extstore.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='extstore.c' object='memcached_debug-extstore.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-extstore.o `test -f 'extstore.c' || echo '$(srcdir)/'`extstore.c memcached_debug-extstore.obj: extstore.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-extstore.obj -MD -MP -MF $(DEPDIR)/memcached_debug-extstore.Tpo -c -o memcached_debug-extstore.obj `if test -f 'extstore.c'; then $(CYGPATH_W) 'extstore.c'; else $(CYGPATH_W) '$(srcdir)/extstore.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-extstore.Tpo $(DEPDIR)/memcached_debug-extstore.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='extstore.c' object='memcached_debug-extstore.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-extstore.obj `if test -f 'extstore.c'; then $(CYGPATH_W) 'extstore.c'; else $(CYGPATH_W) '$(srcdir)/extstore.c'; fi` memcached_debug-crc32c.o: crc32c.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-crc32c.o -MD -MP -MF $(DEPDIR)/memcached_debug-crc32c.Tpo -c -o memcached_debug-crc32c.o `test -f 'crc32c.c' || echo '$(srcdir)/'`crc32c.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-crc32c.Tpo $(DEPDIR)/memcached_debug-crc32c.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='crc32c.c' object='memcached_debug-crc32c.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-crc32c.o `test -f 'crc32c.c' || echo '$(srcdir)/'`crc32c.c memcached_debug-crc32c.obj: crc32c.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-crc32c.obj -MD -MP -MF $(DEPDIR)/memcached_debug-crc32c.Tpo -c -o memcached_debug-crc32c.obj `if test -f 'crc32c.c'; then $(CYGPATH_W) 'crc32c.c'; else $(CYGPATH_W) '$(srcdir)/crc32c.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-crc32c.Tpo $(DEPDIR)/memcached_debug-crc32c.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='crc32c.c' object='memcached_debug-crc32c.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-crc32c.obj `if test -f 'crc32c.c'; then $(CYGPATH_W) 'crc32c.c'; else $(CYGPATH_W) '$(srcdir)/crc32c.c'; fi` memcached_debug-storage.o: storage.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-storage.o -MD -MP -MF $(DEPDIR)/memcached_debug-storage.Tpo -c -o memcached_debug-storage.o `test -f 'storage.c' || echo '$(srcdir)/'`storage.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-storage.Tpo $(DEPDIR)/memcached_debug-storage.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='storage.c' object='memcached_debug-storage.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-storage.o `test -f 'storage.c' || echo '$(srcdir)/'`storage.c memcached_debug-storage.obj: storage.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-storage.obj -MD -MP -MF $(DEPDIR)/memcached_debug-storage.Tpo -c -o memcached_debug-storage.obj `if test -f 'storage.c'; then $(CYGPATH_W) 'storage.c'; else $(CYGPATH_W) '$(srcdir)/storage.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-storage.Tpo $(DEPDIR)/memcached_debug-storage.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='storage.c' object='memcached_debug-storage.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-storage.obj `if test -f 'storage.c'; then $(CYGPATH_W) 'storage.c'; else $(CYGPATH_W) '$(srcdir)/storage.c'; fi` memcached_debug-slab_automove_extstore.o: slab_automove_extstore.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-slab_automove_extstore.o -MD -MP -MF $(DEPDIR)/memcached_debug-slab_automove_extstore.Tpo -c -o memcached_debug-slab_automove_extstore.o `test -f 'slab_automove_extstore.c' || echo '$(srcdir)/'`slab_automove_extstore.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-slab_automove_extstore.Tpo $(DEPDIR)/memcached_debug-slab_automove_extstore.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slab_automove_extstore.c' object='memcached_debug-slab_automove_extstore.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-slab_automove_extstore.o `test -f 'slab_automove_extstore.c' || echo '$(srcdir)/'`slab_automove_extstore.c memcached_debug-slab_automove_extstore.obj: slab_automove_extstore.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-slab_automove_extstore.obj -MD -MP -MF $(DEPDIR)/memcached_debug-slab_automove_extstore.Tpo -c -o memcached_debug-slab_automove_extstore.obj `if test -f 'slab_automove_extstore.c'; then $(CYGPATH_W) 'slab_automove_extstore.c'; else $(CYGPATH_W) '$(srcdir)/slab_automove_extstore.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-slab_automove_extstore.Tpo $(DEPDIR)/memcached_debug-slab_automove_extstore.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='slab_automove_extstore.c' object='memcached_debug-slab_automove_extstore.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-slab_automove_extstore.obj `if test -f 'slab_automove_extstore.c'; then $(CYGPATH_W) 'slab_automove_extstore.c'; else $(CYGPATH_W) '$(srcdir)/slab_automove_extstore.c'; fi` memcached_debug-tls.o: tls.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-tls.o -MD -MP -MF $(DEPDIR)/memcached_debug-tls.Tpo -c -o memcached_debug-tls.o `test -f 'tls.c' || echo '$(srcdir)/'`tls.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-tls.Tpo $(DEPDIR)/memcached_debug-tls.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='tls.c' object='memcached_debug-tls.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-tls.o `test -f 'tls.c' || echo '$(srcdir)/'`tls.c memcached_debug-tls.obj: tls.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -MT memcached_debug-tls.obj -MD -MP -MF $(DEPDIR)/memcached_debug-tls.Tpo -c -o memcached_debug-tls.obj `if test -f 'tls.c'; then $(CYGPATH_W) 'tls.c'; else $(CYGPATH_W) '$(srcdir)/tls.c'; fi` @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/memcached_debug-tls.Tpo $(DEPDIR)/memcached_debug-tls.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='tls.c' object='memcached_debug-tls.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(memcached_debug_CFLAGS) $(CFLAGS) -c -o memcached_debug-tls.obj `if test -f 'tls.c'; then $(CYGPATH_W) 'tls.c'; else $(CYGPATH_W) '$(srcdir)/tls.c'; fi` install-pkgincludeHEADERS: $(pkginclude_HEADERS) @$(NORMAL_INSTALL) @list='$(pkginclude_HEADERS)'; test -n "$(pkgincludedir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(pkgincludedir)'"; \ $(MKDIR_P) "$(DESTDIR)$(pkgincludedir)" || exit 1; \ fi; \ for p in $$list; do \ if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ echo "$$d$$p"; \ done | $(am__base_list) | \ while read files; do \ echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(pkgincludedir)'"; \ $(INSTALL_HEADER) $$files "$(DESTDIR)$(pkgincludedir)" || exit $$?; \ done uninstall-pkgincludeHEADERS: @$(NORMAL_UNINSTALL) @list='$(pkginclude_HEADERS)'; test -n "$(pkgincludedir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ dir='$(DESTDIR)$(pkgincludedir)'; $(am__uninstall_files_from_dir) # This directory's subdirectories are mostly independent; you can cd # into them and run 'make' without going through this Makefile. # To change the values of 'make' variables: instead of editing Makefiles, # (1) if the variable is set in 'config.status', edit 'config.status' # (which will cause the Makefiles to be regenerated when you run 'make'); # (2) otherwise, pass the desired values on the 'make' command line. $(am__recursive_targets): @fail=; \ if $(am__make_keepgoing); then \ failcom='fail=yes'; \ else \ failcom='exit 1'; \ fi; \ dot_seen=no; \ target=`echo $@ | sed s/-recursive//`; \ case "$@" in \ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ *) list='$(SUBDIRS)' ;; \ esac; \ for subdir in $$list; do \ echo "Making $$target in $$subdir"; \ if test "$$subdir" = "."; then \ dot_seen=yes; \ local_target="$$target-am"; \ else \ local_target="$$target"; \ fi; \ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ || eval $$failcom; \ done; \ if test "$$dot_seen" = "no"; then \ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ fi; test -z "$$fail" ID: $(am__tagged_files) $(am__define_uniq_tagged_files); mkid -fID $$unique tags: tags-recursive TAGS: tags tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) set x; \ here=`pwd`; \ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ include_option=--etags-include; \ empty_fix=.; \ else \ include_option=--include; \ empty_fix=; \ fi; \ list='$(SUBDIRS)'; for subdir in $$list; do \ if test "$$subdir" = .; then :; else \ test ! -f $$subdir/TAGS || \ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ fi; \ done; \ $(am__define_uniq_tagged_files); \ shift; \ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ test -n "$$unique" || unique=$$empty_fix; \ if test $$# -gt 0; then \ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ "$$@" $$unique; \ else \ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ $$unique; \ fi; \ fi ctags: ctags-recursive CTAGS: ctags ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) $(am__define_uniq_tagged_files); \ test -z "$(CTAGS_ARGS)$$unique" \ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ $$unique GTAGS: here=`$(am__cd) $(top_builddir) && pwd` \ && $(am__cd) $(top_srcdir) \ && gtags -i $(GTAGS_ARGS) "$$here" cscope: cscope.files test ! -s cscope.files \ || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS) clean-cscope: -rm -f cscope.files cscope.files: clean-cscope cscopelist cscopelist: cscopelist-recursive cscopelist-am: $(am__tagged_files) list='$(am__tagged_files)'; \ case "$(srcdir)" in \ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ *) sdir=$(subdir)/$(srcdir) ;; \ esac; \ for i in $$list; do \ if test -f "$$i"; then \ echo "$(subdir)/$$i"; \ else \ echo "$$sdir/$$i"; \ fi; \ done >> $(top_builddir)/cscope.files distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags -rm -f cscope.out cscope.in.out cscope.po.out cscope.files distdir: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(DISTFILES) $(am__remove_distdir) test -d "$(distdir)" || mkdir "$(distdir)" @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ list='$(DISTFILES)'; \ dist_files=`for file in $$list; do echo $$file; done | \ sed -e "s|^$$srcdirstrip/||;t" \ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ case $$dist_files in \ */*) $(MKDIR_P) `echo "$$dist_files" | \ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ sort -u` ;; \ esac; \ for file in $$dist_files; do \ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ if test -d $$d/$$file; then \ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ if test -d "$(distdir)/$$file"; then \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ else \ test -f "$(distdir)/$$file" \ || cp -p $$d/$$file "$(distdir)/$$file" \ || exit 1; \ fi; \ done @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ if test "$$subdir" = .; then :; else \ $(am__make_dryrun) \ || test -d "$(distdir)/$$subdir" \ || $(MKDIR_P) "$(distdir)/$$subdir" \ || exit 1; \ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ $(am__relativize); \ new_distdir=$$reldir; \ dir1=$$subdir; dir2="$(top_distdir)"; \ $(am__relativize); \ new_top_distdir=$$reldir; \ echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ ($(am__cd) $$subdir && \ $(MAKE) $(AM_MAKEFLAGS) \ top_distdir="$$new_top_distdir" \ distdir="$$new_distdir" \ am__remove_distdir=: \ am__skip_length_check=: \ am__skip_mode_fix=: \ distdir) \ || exit 1; \ fi; \ done $(MAKE) $(AM_MAKEFLAGS) \ top_distdir="$(top_distdir)" distdir="$(distdir)" \ dist-hook -test -n "$(am__skip_mode_fix)" \ || find "$(distdir)" -type d ! -perm -755 \ -exec chmod u+rwx,go+rx {} \; -o \ ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \ ! -type d ! -perm -400 -exec chmod a+r {} \; -o \ ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \ || chmod -R a+r "$(distdir)" dist-gzip: distdir tardir=$(distdir) && $(am__tar) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).tar.gz $(am__post_remove_distdir) dist-bzip2: distdir tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2 $(am__post_remove_distdir) dist-lzip: distdir tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz $(am__post_remove_distdir) dist-xz: distdir tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz $(am__post_remove_distdir) dist-zstd: distdir tardir=$(distdir) && $(am__tar) | zstd -c $${ZSTD_CLEVEL-$${ZSTD_OPT--19}} >$(distdir).tar.zst $(am__post_remove_distdir) dist-tarZ: distdir @echo WARNING: "Support for distribution archives compressed with" \ "legacy program 'compress' is deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z $(am__post_remove_distdir) dist-shar: distdir @echo WARNING: "Support for shar distribution archives is" \ "deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 shar $(distdir) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).shar.gz $(am__post_remove_distdir) dist-zip: distdir -rm -f $(distdir).zip zip -rq $(distdir).zip $(distdir) $(am__post_remove_distdir) dist dist-all: $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:' $(am__post_remove_distdir) # This target untars the dist file and tries a VPATH configuration. Then # it guarantees that the distribution is self-contained by making another # tarfile. distcheck: dist case '$(DIST_ARCHIVES)' in \ *.tar.gz*) \ eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).tar.gz | $(am__untar) ;;\ *.tar.bz2*) \ bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\ *.tar.lz*) \ lzip -dc $(distdir).tar.lz | $(am__untar) ;;\ *.tar.xz*) \ xz -dc $(distdir).tar.xz | $(am__untar) ;;\ *.tar.Z*) \ uncompress -c $(distdir).tar.Z | $(am__untar) ;;\ *.shar.gz*) \ eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).shar.gz | unshar ;;\ *.zip*) \ unzip $(distdir).zip ;;\ *.tar.zst*) \ zstd -dc $(distdir).tar.zst | $(am__untar) ;;\ esac chmod -R a-w $(distdir) chmod u+w $(distdir) mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst chmod a-w $(distdir) test -d $(distdir)/_build || exit 0; \ dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \ && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \ && am__cwd=`pwd` \ && $(am__cd) $(distdir)/_build/sub \ && ../../configure \ $(AM_DISTCHECK_CONFIGURE_FLAGS) \ $(DISTCHECK_CONFIGURE_FLAGS) \ --srcdir=../.. --prefix="$$dc_install_base" \ && $(MAKE) $(AM_MAKEFLAGS) \ && $(MAKE) $(AM_MAKEFLAGS) $(AM_DISTCHECK_DVI_TARGET) \ && $(MAKE) $(AM_MAKEFLAGS) check \ && $(MAKE) $(AM_MAKEFLAGS) install \ && $(MAKE) $(AM_MAKEFLAGS) installcheck \ && $(MAKE) $(AM_MAKEFLAGS) uninstall \ && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \ distuninstallcheck \ && chmod -R a-w "$$dc_install_base" \ && ({ \ (cd ../.. && umask 077 && mkdir "$$dc_destdir") \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \ distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \ } || { rm -rf "$$dc_destdir"; exit 1; }) \ && rm -rf "$$dc_destdir" \ && $(MAKE) $(AM_MAKEFLAGS) dist \ && rm -rf $(DIST_ARCHIVES) \ && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \ && cd "$$am__cwd" \ || exit 1 $(am__post_remove_distdir) @(echo "$(distdir) archives ready for distribution: "; \ list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \ sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x' distuninstallcheck: @test -n '$(distuninstallcheck_dir)' || { \ echo 'ERROR: trying to run $@ with an empty' \ '$$(distuninstallcheck_dir)' >&2; \ exit 1; \ }; \ $(am__cd) '$(distuninstallcheck_dir)' || { \ echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \ exit 1; \ }; \ test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \ || { echo "ERROR: files left after uninstall:" ; \ if test -n "$(DESTDIR)"; then \ echo " (check DESTDIR support)"; \ fi ; \ $(distuninstallcheck_listfiles) ; \ exit 1; } >&2 distcleancheck: distclean @if test '$(srcdir)' = . ; then \ echo "ERROR: distcleancheck can only run from a VPATH build" ; \ exit 1 ; \ fi @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \ || { echo "ERROR: files left in build directory after distclean:" ; \ $(distcleancheck_listfiles) ; \ exit 1; } >&2 check-am: all-am check: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) check-recursive all-am: Makefile $(PROGRAMS) $(HEADERS) config.h installdirs: installdirs-recursive installdirs-am: for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(pkgincludedir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) install-recursive install-exec: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) install-exec-recursive install-data: install-data-recursive uninstall: uninstall-recursive install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-recursive install-strip: if test -z '$(STRIP)'; then \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ install; \ else \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ fi mostlyclean-generic: -test -z "$(MOSTLYCLEANFILES)" || rm -f $(MOSTLYCLEANFILES) clean-generic: -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) distclean-generic: -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." -test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES) clean: clean-recursive clean-am: clean-binPROGRAMS clean-generic clean-noinstPROGRAMS \ mostlyclean-am distclean: distclean-recursive -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -f ./$(DEPDIR)/cache.Po -rm -f ./$(DEPDIR)/crc32c.Po -rm -f ./$(DEPDIR)/jenkins_hash.Po -rm -f ./$(DEPDIR)/memcached-assoc.Po -rm -f ./$(DEPDIR)/memcached-authfile.Po -rm -f ./$(DEPDIR)/memcached-base64.Po -rm -f ./$(DEPDIR)/memcached-bipbuffer.Po -rm -f ./$(DEPDIR)/memcached-cache.Po -rm -f ./$(DEPDIR)/memcached-crawler.Po -rm -f ./$(DEPDIR)/memcached-crc32c.Po -rm -f ./$(DEPDIR)/memcached-daemon.Po -rm -f ./$(DEPDIR)/memcached-darwin_priv.Po -rm -f ./$(DEPDIR)/memcached-extstore.Po -rm -f ./$(DEPDIR)/memcached-freebsd_priv.Po -rm -f ./$(DEPDIR)/memcached-hash.Po -rm -f ./$(DEPDIR)/memcached-items.Po -rm -f ./$(DEPDIR)/memcached-itoa_ljust.Po -rm -f ./$(DEPDIR)/memcached-jenkins_hash.Po -rm -f ./$(DEPDIR)/memcached-linux_priv.Po -rm -f ./$(DEPDIR)/memcached-logger.Po -rm -f ./$(DEPDIR)/memcached-md5.Po -rm -f ./$(DEPDIR)/memcached-memcached.Po -rm -f ./$(DEPDIR)/memcached-murmur3_hash.Po -rm -f ./$(DEPDIR)/memcached-openbsd_priv.Po -rm -f ./$(DEPDIR)/memcached-proto_bin.Po -rm -f ./$(DEPDIR)/memcached-proto_proxy.Po -rm -f ./$(DEPDIR)/memcached-proto_text.Po -rm -f ./$(DEPDIR)/memcached-proxy_await.Po -rm -f ./$(DEPDIR)/memcached-proxy_config.Po -rm -f ./$(DEPDIR)/memcached-proxy_internal.Po -rm -f ./$(DEPDIR)/memcached-proxy_jump_hash.Po -rm -f ./$(DEPDIR)/memcached-proxy_lua.Po -rm -f ./$(DEPDIR)/memcached-proxy_network.Po -rm -f ./$(DEPDIR)/memcached-proxy_request.Po -rm -f ./$(DEPDIR)/memcached-proxy_ring_hash.Po -rm -f ./$(DEPDIR)/memcached-proxy_ustats.Po -rm -f ./$(DEPDIR)/memcached-proxy_xxhash.Po -rm -f ./$(DEPDIR)/memcached-restart.Po -rm -f ./$(DEPDIR)/memcached-sasl_defs.Po -rm -f ./$(DEPDIR)/memcached-slab_automove.Po -rm -f ./$(DEPDIR)/memcached-slab_automove_extstore.Po -rm -f ./$(DEPDIR)/memcached-slabs.Po -rm -f ./$(DEPDIR)/memcached-solaris_priv.Po -rm -f ./$(DEPDIR)/memcached-stats_prefix.Po -rm -f ./$(DEPDIR)/memcached-storage.Po -rm -f ./$(DEPDIR)/memcached-thread.Po -rm -f ./$(DEPDIR)/memcached-tls.Po -rm -f ./$(DEPDIR)/memcached-util.Po -rm -f ./$(DEPDIR)/memcached_debug-assoc.Po -rm -f ./$(DEPDIR)/memcached_debug-authfile.Po -rm -f ./$(DEPDIR)/memcached_debug-base64.Po -rm -f ./$(DEPDIR)/memcached_debug-bipbuffer.Po -rm -f ./$(DEPDIR)/memcached_debug-cache.Po -rm -f ./$(DEPDIR)/memcached_debug-crawler.Po -rm -f ./$(DEPDIR)/memcached_debug-crc32c.Po -rm -f ./$(DEPDIR)/memcached_debug-daemon.Po -rm -f ./$(DEPDIR)/memcached_debug-darwin_priv.Po -rm -f ./$(DEPDIR)/memcached_debug-extstore.Po -rm -f ./$(DEPDIR)/memcached_debug-freebsd_priv.Po -rm -f ./$(DEPDIR)/memcached_debug-hash.Po -rm -f ./$(DEPDIR)/memcached_debug-items.Po -rm -f ./$(DEPDIR)/memcached_debug-itoa_ljust.Po -rm -f ./$(DEPDIR)/memcached_debug-jenkins_hash.Po -rm -f ./$(DEPDIR)/memcached_debug-linux_priv.Po -rm -f ./$(DEPDIR)/memcached_debug-logger.Po -rm -f ./$(DEPDIR)/memcached_debug-md5.Po -rm -f ./$(DEPDIR)/memcached_debug-memcached.Po -rm -f ./$(DEPDIR)/memcached_debug-murmur3_hash.Po -rm -f ./$(DEPDIR)/memcached_debug-openbsd_priv.Po -rm -f ./$(DEPDIR)/memcached_debug-proto_bin.Po -rm -f ./$(DEPDIR)/memcached_debug-proto_proxy.Po -rm -f ./$(DEPDIR)/memcached_debug-proto_text.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_await.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_config.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_internal.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_jump_hash.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_lua.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_network.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_request.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_ring_hash.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_ustats.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_xxhash.Po -rm -f ./$(DEPDIR)/memcached_debug-restart.Po -rm -f ./$(DEPDIR)/memcached_debug-sasl_defs.Po -rm -f ./$(DEPDIR)/memcached_debug-slab_automove.Po -rm -f ./$(DEPDIR)/memcached_debug-slab_automove_extstore.Po -rm -f ./$(DEPDIR)/memcached_debug-slabs.Po -rm -f ./$(DEPDIR)/memcached_debug-solaris_priv.Po -rm -f ./$(DEPDIR)/memcached_debug-stats_prefix.Po -rm -f ./$(DEPDIR)/memcached_debug-storage.Po -rm -f ./$(DEPDIR)/memcached_debug-thread.Po -rm -f ./$(DEPDIR)/memcached_debug-tls.Po -rm -f ./$(DEPDIR)/memcached_debug-util.Po -rm -f ./$(DEPDIR)/murmur3_hash.Po -rm -f ./$(DEPDIR)/sizes.Po -rm -f ./$(DEPDIR)/stats_prefix.Po -rm -f ./$(DEPDIR)/testapp.Po -rm -f ./$(DEPDIR)/timedrun.Po -rm -f ./$(DEPDIR)/util.Po -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ distclean-hdr distclean-tags dvi: dvi-recursive dvi-am: html: html-recursive html-am: info: info-recursive info-am: install-data-am: install-pkgincludeHEADERS install-dvi: install-dvi-recursive install-dvi-am: install-exec-am: install-binPROGRAMS install-html: install-html-recursive install-html-am: install-info: install-info-recursive install-info-am: install-man: install-pdf: install-pdf-recursive install-pdf-am: install-ps: install-ps-recursive install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-recursive -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf $(top_srcdir)/autom4te.cache -rm -f ./$(DEPDIR)/cache.Po -rm -f ./$(DEPDIR)/crc32c.Po -rm -f ./$(DEPDIR)/jenkins_hash.Po -rm -f ./$(DEPDIR)/memcached-assoc.Po -rm -f ./$(DEPDIR)/memcached-authfile.Po -rm -f ./$(DEPDIR)/memcached-base64.Po -rm -f ./$(DEPDIR)/memcached-bipbuffer.Po -rm -f ./$(DEPDIR)/memcached-cache.Po -rm -f ./$(DEPDIR)/memcached-crawler.Po -rm -f ./$(DEPDIR)/memcached-crc32c.Po -rm -f ./$(DEPDIR)/memcached-daemon.Po -rm -f ./$(DEPDIR)/memcached-darwin_priv.Po -rm -f ./$(DEPDIR)/memcached-extstore.Po -rm -f ./$(DEPDIR)/memcached-freebsd_priv.Po -rm -f ./$(DEPDIR)/memcached-hash.Po -rm -f ./$(DEPDIR)/memcached-items.Po -rm -f ./$(DEPDIR)/memcached-itoa_ljust.Po -rm -f ./$(DEPDIR)/memcached-jenkins_hash.Po -rm -f ./$(DEPDIR)/memcached-linux_priv.Po -rm -f ./$(DEPDIR)/memcached-logger.Po -rm -f ./$(DEPDIR)/memcached-md5.Po -rm -f ./$(DEPDIR)/memcached-memcached.Po -rm -f ./$(DEPDIR)/memcached-murmur3_hash.Po -rm -f ./$(DEPDIR)/memcached-openbsd_priv.Po -rm -f ./$(DEPDIR)/memcached-proto_bin.Po -rm -f ./$(DEPDIR)/memcached-proto_proxy.Po -rm -f ./$(DEPDIR)/memcached-proto_text.Po -rm -f ./$(DEPDIR)/memcached-proxy_await.Po -rm -f ./$(DEPDIR)/memcached-proxy_config.Po -rm -f ./$(DEPDIR)/memcached-proxy_internal.Po -rm -f ./$(DEPDIR)/memcached-proxy_jump_hash.Po -rm -f ./$(DEPDIR)/memcached-proxy_lua.Po -rm -f ./$(DEPDIR)/memcached-proxy_network.Po -rm -f ./$(DEPDIR)/memcached-proxy_request.Po -rm -f ./$(DEPDIR)/memcached-proxy_ring_hash.Po -rm -f ./$(DEPDIR)/memcached-proxy_ustats.Po -rm -f ./$(DEPDIR)/memcached-proxy_xxhash.Po -rm -f ./$(DEPDIR)/memcached-restart.Po -rm -f ./$(DEPDIR)/memcached-sasl_defs.Po -rm -f ./$(DEPDIR)/memcached-slab_automove.Po -rm -f ./$(DEPDIR)/memcached-slab_automove_extstore.Po -rm -f ./$(DEPDIR)/memcached-slabs.Po -rm -f ./$(DEPDIR)/memcached-solaris_priv.Po -rm -f ./$(DEPDIR)/memcached-stats_prefix.Po -rm -f ./$(DEPDIR)/memcached-storage.Po -rm -f ./$(DEPDIR)/memcached-thread.Po -rm -f ./$(DEPDIR)/memcached-tls.Po -rm -f ./$(DEPDIR)/memcached-util.Po -rm -f ./$(DEPDIR)/memcached_debug-assoc.Po -rm -f ./$(DEPDIR)/memcached_debug-authfile.Po -rm -f ./$(DEPDIR)/memcached_debug-base64.Po -rm -f ./$(DEPDIR)/memcached_debug-bipbuffer.Po -rm -f ./$(DEPDIR)/memcached_debug-cache.Po -rm -f ./$(DEPDIR)/memcached_debug-crawler.Po -rm -f ./$(DEPDIR)/memcached_debug-crc32c.Po -rm -f ./$(DEPDIR)/memcached_debug-daemon.Po -rm -f ./$(DEPDIR)/memcached_debug-darwin_priv.Po -rm -f ./$(DEPDIR)/memcached_debug-extstore.Po -rm -f ./$(DEPDIR)/memcached_debug-freebsd_priv.Po -rm -f ./$(DEPDIR)/memcached_debug-hash.Po -rm -f ./$(DEPDIR)/memcached_debug-items.Po -rm -f ./$(DEPDIR)/memcached_debug-itoa_ljust.Po -rm -f ./$(DEPDIR)/memcached_debug-jenkins_hash.Po -rm -f ./$(DEPDIR)/memcached_debug-linux_priv.Po -rm -f ./$(DEPDIR)/memcached_debug-logger.Po -rm -f ./$(DEPDIR)/memcached_debug-md5.Po -rm -f ./$(DEPDIR)/memcached_debug-memcached.Po -rm -f ./$(DEPDIR)/memcached_debug-murmur3_hash.Po -rm -f ./$(DEPDIR)/memcached_debug-openbsd_priv.Po -rm -f ./$(DEPDIR)/memcached_debug-proto_bin.Po -rm -f ./$(DEPDIR)/memcached_debug-proto_proxy.Po -rm -f ./$(DEPDIR)/memcached_debug-proto_text.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_await.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_config.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_internal.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_jump_hash.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_lua.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_network.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_request.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_ring_hash.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_ustats.Po -rm -f ./$(DEPDIR)/memcached_debug-proxy_xxhash.Po -rm -f ./$(DEPDIR)/memcached_debug-restart.Po -rm -f ./$(DEPDIR)/memcached_debug-sasl_defs.Po -rm -f ./$(DEPDIR)/memcached_debug-slab_automove.Po -rm -f ./$(DEPDIR)/memcached_debug-slab_automove_extstore.Po -rm -f ./$(DEPDIR)/memcached_debug-slabs.Po -rm -f ./$(DEPDIR)/memcached_debug-solaris_priv.Po -rm -f ./$(DEPDIR)/memcached_debug-stats_prefix.Po -rm -f ./$(DEPDIR)/memcached_debug-storage.Po -rm -f ./$(DEPDIR)/memcached_debug-thread.Po -rm -f ./$(DEPDIR)/memcached_debug-tls.Po -rm -f ./$(DEPDIR)/memcached_debug-util.Po -rm -f ./$(DEPDIR)/murmur3_hash.Po -rm -f ./$(DEPDIR)/sizes.Po -rm -f ./$(DEPDIR)/stats_prefix.Po -rm -f ./$(DEPDIR)/testapp.Po -rm -f ./$(DEPDIR)/timedrun.Po -rm -f ./$(DEPDIR)/util.Po -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic \ maintainer-clean-local mostlyclean: mostlyclean-recursive mostlyclean-am: mostlyclean-compile mostlyclean-generic pdf: pdf-recursive pdf-am: ps: ps-recursive ps-am: uninstall-am: uninstall-binPROGRAMS uninstall-pkgincludeHEADERS .MAKE: $(am__recursive_targets) all check install install-am \ install-exec install-strip .PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \ am--depfiles am--refresh check check-am clean \ clean-binPROGRAMS clean-cscope clean-generic \ clean-noinstPROGRAMS cscope cscopelist-am ctags ctags-am dist \ dist-all dist-bzip2 dist-gzip dist-hook dist-lzip dist-shar \ dist-tarZ dist-xz dist-zip dist-zstd distcheck distclean \ distclean-compile distclean-generic distclean-hdr \ distclean-tags distcleancheck distdir distuninstallcheck dvi \ dvi-am html html-am info info-am install install-am \ install-binPROGRAMS install-data install-data-am install-dvi \ install-dvi-am install-exec install-exec-am install-html \ install-html-am install-info install-info-am install-man \ install-pdf install-pdf-am install-pkgincludeHEADERS \ install-ps install-ps-am install-strip installcheck \ installcheck-am installdirs installdirs-am maintainer-clean \ maintainer-clean-generic maintainer-clean-local mostlyclean \ mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \ tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \ uninstall-pkgincludeHEADERS .PRECIOUS: Makefile # build fails on Darwin with const signature replacements. @DARWIN_TRUE@memcached_dtrace.h: memcached_dtrace.d @DARWIN_TRUE@ ${DTRACE} -h -s memcached_dtrace.d @DARWIN_FALSE@memcached_dtrace.h: memcached_dtrace.d @DARWIN_FALSE@ ${DTRACE} -h -s memcached_dtrace.d @DARWIN_FALSE@ sed -e 's,void \*,const void \*,' memcached_dtrace.h | \ @DARWIN_FALSE@ sed -e 's,char \*,const char \*,g' | tr '\t' ' ' > mmc_dtrace.tmp @DARWIN_FALSE@ mv mmc_dtrace.tmp memcached_dtrace.h memcached_dtrace.o: $(memcached_OBJECTS) $(DTRACE) $(DTRACEFLAGS) -G -o memcached_dtrace.o -s ${srcdir}/memcached_dtrace.d $(memcached_OBJECTS) memcached_debug_dtrace.o: $(memcached_debug_OBJECTS) $(DTRACE) $(DTRACEFLAGS) -G -o memcached_debug_dtrace.o -s ${srcdir}/memcached_dtrace.d $(memcached_debug_OBJECTS) @ENABLE_TLS_TRUE@test_tls: @ENABLE_TLS_TRUE@ $(MAKE) SSL_TEST=1 test @ENABLE_TLS_TRUE@test_basic_tls: @ENABLE_TLS_TRUE@ @if test $(SSL_TEST)1 != 1; then \ @ENABLE_TLS_TRUE@ echo "Running basic tests with TLS"; \ @ENABLE_TLS_TRUE@ $(builddir)/testapp && \ @ENABLE_TLS_TRUE@ prove $(srcdir)/t/binary.t $(srcdir)/t/getset.t $(srcdir)/t/ssl* && \ @ENABLE_TLS_TRUE@ echo "Finished running basic TLS tests"; \ @ENABLE_TLS_TRUE@ else \ @ENABLE_TLS_TRUE@ echo "Set SSL_TEST=1 to enable TLS tests"; \ @ENABLE_TLS_TRUE@ fi test: memcached-debug sizes testapp $(builddir)/sizes $(builddir)/testapp @ENABLE_TLS_TRUE@ @if test $(SSL_TEST)1 = 1; then \ @ENABLE_TLS_TRUE@ $(MAKE) SSL_TEST=1 test_basic_tls; \ @ENABLE_TLS_TRUE@ fi @if test -n "${PARALLEL}"; then \ prove $(srcdir)/t -j ${PARALLEL}; \ else \ prove $(srcdir)/t; \ fi @if test `basename $(PROFILER)` = "gcov"; then \ for file in memcached_debug-*.gc??; do \ mv -f $$file `echo $$file | sed 's/memcached_debug-//'`; \ done && \ for file in *.gcda; do \ srcfile=`echo $$file | sed 's/.gcda/.c/'`; \ if test -n "`echo $(memcached_debug_SOURCES) | grep $$srcfile`"; then \ echo `$(PROFILER) $$srcfile` | sed 's/'$$srcfile':.*//'; \ fi \ done \ elif test `basename $(PROFILER)` = "tcov"; then \ files=`grep SRCFILE memcached-debug.profile/tcovd | sed 's/SRCFILE://' | sort | uniq` && \ $(PROFILER) -x memcached-debug.profile $$files 2>&1; \ for file in *.tcov; do \ srcfile=`echo $$file | sed 's/.tcov//'`; \ if test -n "`echo $(memcached_debug_SOURCES) | grep $$srcfile`"; then \ echo $$srcfile : `grep 'Percent of the file executed' $$file`; \ fi \ done \ else :; fi docs: (cat Doxyfile ; echo "PROJECT_NUMBER=`cat version.num`") | doxygen - dist-hook: rm -f $(distdir)/*/*~ $(distdir)/t/lib/*~ $(distdir)/*~ maintainer-clean-local: -rm Makefile.in -rm aclocal.m4 -rm config.guess -rm config.sub -rm depcomp -rm install-sh -rm ltmain.sh -rm missing -rm configure -rm config.log -rm config.status # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: memcached-1.6.20/ChangeLog0000664000175000017500000004632514204760331012215 000000000000002016-08-23 * ChangeLog moved from Google Code to Github Wiki, it's now available at: https://github.com/memcached/memcached/wiki/ReleaseNotes 2010-10-11 * ChangeLog is no longer being updated. See http://code.google.com/p/memcached/wiki/ReleaseNotes 2009-04-10 * *critical bugfix*. In 1.2.7 under multithreaded mode, memcached would never restart accepting connections after hitting the maximum connection limit. 2009-04-02 * Fix: Rewrote stat buffer handling (Trond) 2009-03-31 * Feature: -b option for configuring backlog * Feature: stats settings * Fix: binary stat alignment bug (bug26) * Fix: buffer overflow in stats (bug27) * Fix: recycle memory more aggressively (bug14) * Fix: incr validation (bug31) * Fix: 64-bit incr/decr delta problem (bug21) * Fix: Ascii UDP set (bug36) * Fix: stats slabs' used chunks (bug29) * Fix: stats reset resetting more (bug22) * Misc: More tests, documentation, cleanliness (godliness) * Stable merge (stats, debuggability, listen bugs) 2009-03-11 * Protocol: Binary complete (Dustin, Trond, Toru, etc...) * Performance: improvements from facebook (Dormando) * Performance: per-thread stats (Trond) * Performance: Hash expansion in its own thread (Trond) * Stats: Lots of new stats (Dustin) * Bug fixes (various) See the 1.3.2 release notes or revision control for more detail. 2008-09-06 * Display error status on listen failures (Dormando) * Remove managed instance code. Incomplete/etc. (Dormando) * Handle broken IPV6 stacks better (Brian Aker) * Generate warnings on setsockopt() failures (Brian Aker) * Fix some indentation issues (Brian Aker) * UDP/TCP can be disabled by setting their port to zero (Brian Aker) * Zero out libevent thread structures before use (Ricky Zhou) * New stat: Last accessed time for last evicted item per slab class. (Dormando) * Use a dedicated socket accept thread (Facebook) * Add -R option. Limit the number of requests processed by a connection at once. Prevents starving other threads if bulk loading. (Facebook) 2008-07-29 [Version 1.2.6 released] 2008-07-24 [Version 1.2.6-rc1 released] * Add support for newer automake (Facebook) * DTrace support for Solaris/etc (Trond Norbye) * LRU tests (Steve Yen) * Handle negative length items properly (Dormando) * Don't leave stale data after failed set attempts (Dormando) * Fix refcount leaks, which would result in OOM's on all sets (Dormando) * Fix buffer overruns (Dustin Sallings, Tomash Brechko) * Fix memory corruption with CAS (Dustin Sallings) 2008-06-11 * Fix -k to work with -d. (reported by Gary Zhu) 2008-03-02 [Version 1.2.5-rc1 released] * Add per-item-class tracking of evictions and OOM errors (dormando) * Optimize item_alloc() a little (dormando) * Give 'SERVER_ERROR out of memory' errors more context (dormando) * Enable usage of large memory pages under solaris (Trond.Norbye@Sun.COM) * Enable UDP by default, clean up server socket code (brian@tangent.org) * 'noreply' support (Tomash Brechko) * IPv6 support, and IPv6 multi-interface support (brian@tangent.org) * Add compiler options for Sun Studio compilers with --enable-threads (Trond.Norbye@Sun.COM) * Add --enable-64bit for mulitarget platforms (Trond.Norbye@Sun.COM) * Use gettimeofday(2) instead of time(2). * Make -k option work (Tomash Brechko) * Fix chunk slab alignment (Trond.Norbye@Sun.COM) 2007-12-06 [Version 1.2.4 released] 2007-12-05 * Fix compilation on panther (JS and Dormando) * More CAS tests (Chris Goffinet) * Final fixes for all 1.2.4 features are in, -rc2 sent out. 2007-11-19 [Version 1.2.4-rc1 released] 2007-11-19 Dormando * Patch series from Tomash Brechko : Minor fixes and optimizations. * Patches from Chris, Dustin, and Dormando to fix CAS. * Prepping for 1.2.4 release. 2007-11-13 Dormando * Adjusted patch from js : Compile on OS X Panther and earlier. 2007-11-12 Steven Grimm * Patch from Tomash Brechko : Always send "SERVER_ERROR out of memory" when memory exhausted. 2007-10-15 Paul Lindner * Patch from David Bremner that implements a new option "-a" which takes an octal permission mask (like chmod) sets the permissions on the unix domain socket (specified by "-s"). 2007-10-03 Paul Lindner * Incorporate "cas" operation developed by Dustin Sallings This change allows you to do atomic changes to an existing key. * Fix for stats.evictions not incrementing when exptime == 0 items are kicked off the cache. from Jean-Francois BUSTARRET . * Fix for do_item_cachedump() which was returning an incorrect timestamp. * Switch to unsigned 64-bit increment/decrement counters from Evan Miller and Dustin Sallings. * Add append command support written by Filipe Laborde. Thread safe version plus prepend command from Maxim Dounin * The memcached-tool script can now display stats. Patch provided by Dan Christian * Fix for Unix Domain sockets on FreeBSD FreeBSD's sendmsg() requires msg_name in msghdr structure to be NULL if not used, setting msg_namelen to 0 isn't enough. Patch from Maxim Dounin 2007-08-21 Paul Lindner * Incorporate increment patch from Evan Miller to define increment overflow behavior. 2007-08-07 Leon Brocard * Bring the memcached.1 manpage up to date 2007-08-06 Paul Lindner * Fix crash when using -P and -d flags on x86_64 with latest libevent release. 2007-07-08 Steven Grimm * Item stats commands weren't thread-safe; wrap them with locks when compiled in multithreaded mode. * The "stats items" command now works again; it broke with the introduction of the powers-of-N chunk size change. 2007-07-06 [Version 1.2.3 released] 2007-06-19 Paul Lindner * Solaris portability fixes from Trond Norbye 2007-05-29 Paul Lindner * Properly document evictions statistic value 2007-05-10 Paul Lindner * Flesh out tests for unix domain sockets and binary data. * Update rpm spec file to run tests 2007-05-07 Paul Lindner * Fix compilation bug on freebsd 6.x (and maybe others) * Update RPM spec file per redhat bugzilla #238994 * Move unistd.h to memcached.h to get rid of warnings * Add string.h to thread.c to get correctly prototyped strerror() 2007-05-04 Paul Lindner * Add fedora/redhat style init script and RPM spec file 2007-05-12 [Version 1.2.2 released] 2007-04-16 Steven Grimm * Command tokenizer performance and cleanliness improvement. Patch contributed by Paolo Borelli . 2007-04-16 Paul Lindner * Add notes to README about MacOS, libevent and kqueue. * Windows Patch integration -- part 1, warnings elimination. 2007-04-12 Paul Lindner * Allow changes to the verbosity level of the server with a new "verbosity" command and some compiler cleanups. Patch contributed by Paolo Borelli . 2007-04-08 Paul Lindner * Add cleanup patch from "Tim Yardley" to clean up source spacing issues, fix -Wall warnings, add some null checks, adds asserts at the top of each function for any use of conn *c without checking to see if c is NULL first. * Also adjust clean-whitespace.pl to clean *.ac files. Add script to test-suite to test for tabs. 2007-04-04 Paul Lindner * Add clarification of flush_all in the protocol docs from Elizabeth Mattijsen 2007-03-31 Paul Lindner * Add patch from Eli Bingham to re-enable the -n switch to memcached. 2007-03-20 Paul Lindner * Add patch to collect eviction statistics from Jean-Francois BUSTARRET . * Updated docs, added new test cases for t/stats.t 2007-03-18 Paul Lindner * Add more test cases using larger buffer sizes up to and greater than 1MB. * Remove unused parameter to item_size_ok() * Use a single printf() in usage() * Add a failing test for conforming with maximum connections. 2007-03-17 * crash fix from Thomas van Gulick in conn_shrink(), passing &ptr, instead of ptr to realloc(). 2007-03-05 Paul Lindner * Fix a number of places where (s)printf calls were using unsigned or signed formats that did not match their arguments. * Add support for stdbool.h and stdint.h to use the bool and uint8_t types. * Major refactoring - move API calls for assoc/items/slabs to their own individual header files. Add appropriate const and static declarations as appropriate. * Avoid type-punning. Do a more efficient realloc inside the conn_shrink routine. * Fix overflow bug where uninitialized access to slabclass caused size-0 mallocs during slab preallocation. * Use EXIT_SUCCESS/EXIT_FAILURE constants. * Convert some sprintf calls to snprintf to protect against buffer overflows. * Explicitly compare against NULL or zero in many places. 2007-03-05 * Steven Grimm : Per-object-type stats collection support. Specify the object type delimiter with the -D command line option. Turn stats gathering on and off with "stats detail on" and "stats detail off". Dump the per-object-type details with "stats detail dump". 2007-03-01 * Steven Grimm : Fix an off-by-one error in the multithreaded version's message passing code. 2006-12-23 * fix expirations of items set with absolute expiration times in the past, before the server's start time. bug was introduced in 1.2.0 with rel_time_t. Thanks to Adam Dixon for the bug report and test case! 2006-11-26 * Steven Grimm : Performance improvements: Dynamic sizing of hashtable to reduce collisions on very large caches and conserve memory on small caches. Only reposition items in the LRU queue once a minute, to reduce overhead of accessing extremely frequently-used items. Stop listening for new connections until an existing one closes if we run out of available file descriptors. Command parser refactoring: Add a single-pass tokenizer to cut down on string scanning. Split the command processing into separate functions for easier profiling and better readability. Pass key lengths along with the keys in all API functions that need keys, to avoid needing to call strlen() repeatedly. 2006-11-25 * Steve Peters : OpenBSD has a malloc.h, but warns to use stdlib.h instead 2006-11-22 * Steven Grimm : Add support for multithreaded execution. Run configure with "--enable-threads" to enable. See doc/threads.txt for details. 2006-11-13 * Iain Wade : Fix for UDP responses on non-"get" commands. 2006-10-15 * Steven Grimm : Dynamic sizing of hashtable to reduce collisions on very large caches and conserve memory on small caches. 2006-10-13 * Steven Grimm : New faster hash function. 2006-09-20 * don't listen on UDP by default; more clear message when UDP port in use 2006-09-09 * release 1.2.0 (along with 1.1.13, which is the more tested branch) nobody has run 1.2.0 in production, to my knowledge. facebook has run their pre-merge-with-trunk version, but bugs were discovered (and fixed) after the merge. there might be more. you've been warned. :) 2006-09-04 * improved autoconf libevent detection, from the Tor project. 2006-09-03 * test suite and lot of expiration, delete, flush_all, etc corner case bugs fixed (Brad Fitzpatrick) 2006-09-02 * Nathan Neulinger : fix breakage in expiration code causing expiration times to not be processed correctly. 2006-08-21 * Nathan Neulinger : fix incompatibilities with unix domain socket support and the UDP code and clean up stale sockets 2006-08-20 * Nathan Neulinger : unix domain socket support 2006-05-03 * Steven Grimm : big bunch of changes: big CPU reduction work, UDP-based interface, increased memory efficiency. (intertwined patch, committed all together) or see svn commit logs 2006-04-30 * River Tarnell: autoconf work for Solaris 10. Brad: merge and verify it works on Nexenta. 2006-03-04 * avva: bucket/generation patch (old, but Brad's just finally committing it) 2006-01-01 * Brad Fitzpatrick : allocate 1 slab per class on start-up, to avoid confusing users with out-of-memory errors later. this is 18 MB of allocation on start, unless max memory allowed with -m is lower, in which case only the smaller slab classes are allocated. 2005-08-09 * Elizabeth Mattijsen : needed a way to flush all memcached backend servers, but not at exactly the same time (to reduce load peaks), I've added some simple functionality to the memcached protocol in the "flush_all" command that allows you to specify a time at which the flush will actually occur (instead of always at the moment the "flush_all" command is received). 2005-05-25 * patch from Peter van Dijk to make stderr unbuffered, for running under daemontools 2005-04-04 * patch from Don MacAskill 'flush_all' doesn't seem to work properly. Basically, if you try to add a key which is present, but expired, the store fails but the old key is no longer expired. * release 1.1.12 2005-01-14 * Date: Thu, 18 Nov 2004 15:25:59 -0600 From: David Phillips Here is a patch to configure.ac and Makefile.am to put the man page in the correct location. Trying to install the man page from a subdirectory results in the subdirectory being used in the install path (it tries to install to doc/memcached.1). This is the correct thing to do: - create a Makefile.am in the doc directory that installs the man page with man_MANS - modify Makefile.am in the base directory to reference the doc directory using SUBDIRS - modify the AC_CONFIG_FILES macro in configure.ac to output the Makefile in doc 2005-01-14 * pidfile saving support from Lisa Seelye , sent Jan 13, 2005 2005-01-14 * don't delete libevent events that haven't been added (the deltimer) patch from Ted Schundler 2004-12-10 * document -M and -r in manpage (Doug Porter ) 2004-07-22 * fix buffer overflow in items.c with 250 byte keys along with other info on the same line going into a 256 byte char[]. thanks to Andrei Nigmatulin 2004-06-15 * immediate deletes weren't being unlinked a few seconds, preventing "add" commands to the same key in that time period. thanks to Michael Alan Dorman for the bug report and demo script. 2004-04-30 * released 1.1.11 2004-04-24 * Avva: Add a new command line option: -r , to maximize core file limit. 2004-03-31 * Avva: Use getrlimit and setrlimit to set limits for number of simultaneously open file descriptors. Get the current limits and try to raise them if they're not enough for the specified (or the default) setting of max connections. 2004-02-24 * Adds a '-M' flag to turn off tossing items from the cache. (Jason Titus ) 2004-02-19 (Evan) * Install manpage on "make install", etc. 2003-12-30 (Brad) * remove static build stuff. interferes with PAM setuid stuff and was only included as a possible fix with the old memory allocator. really shouldn't make a difference. * add Jay Bonci's Debian scripts and manpage * release version 1.1.10 2003-12-01 (Avva) * New command: flush_all, causes all existing items to be invalidated immediately (without deleting them from memory, merely causing memcached to no longer return them). 2003-10-23 * Shift init code around to fix daemon mode on FreeBSD, * and drop root only after creating the server socket (to * allow the use of privileged ports) * version 1.1.10pre 2003-10-09 * BSD compile fixes from Ryan T. Dean * version 1.1.9 2003-09-29 * ignore SIGPIPE at start instead of crashing in rare cases it comes up. no other code had to be modified, since everything else is already dead-connection-aware. (avva) 2003-09-09 (Avva, Lisa Marie Seelye ) * setuid support 2003-09-05 (Avva) * accept all new connections in the same event (so we work with ET epoll) * mark all items as clsid=0 after slab page reassignment to please future asserts (on the road to making slab page reassignment work fully) 2003-08-12 (Brad Fitzpatrick) * use TCP_CORK on Linux or TCP_PUSH on BSD * only use TCP_NODELAY when we don't have alternatives 2003-08-10 * disable Nagel's Algorithm (TCP_NODELAY) for better performance (avva) 2003-08-10 * support multiple levels of verbosity (-vv) 2003-08-10 (Evan Martin) * Makefile.am: debug, optimization, and static flags are controlled by the configure script. * configure.ac: - allow specifying libevent directory with --with-libevent=DIR - check for malloc.h (unavailable on BSDs) - check for socklen_t (unavailable on OSX) * assoc.c, items.c, slabs.c: Remove some unused headers. * memcached.c: allow for nonexistence of malloc.h; #define a POSIX macro to import mlockall flags. 2003-07-29 * version 1.1.7 * big bug fix: item exptime 0 meant expire immediately, not never * version 1.1.8 2003-07-22 * make 'delete' take second arg, of time to refuse new add/replace * set/add/replace/delete can all take abs or delta time (delta can't be larger than a month) 2003-07-21 * added doc/protocol.txt 2003-07-01 * report CPU usage in stats 2003-06-30 * version 1.1.6 * fix a number of obscure bugs * more stats reporting 2003-06-10 * removing use of Judy; use a hash. (judy caused memory fragmentation) * shrink some structures * security improvements * version 1.1.0 2003-06-18 * changing maxsize back to an unsigned int 2003-06-16 * adding PHP support * added CONTRIBUTORS file * version 1.0.4 2003-06-15 * forgot to distribute website/api (still learning auto*) * version 1.0.3 2003-06-15 * update to version 1.0.2 * autoconf/automake fixes for older versions * make stats report version number * change license from GPL to BSD Fri, 13 Jun 2003 10:05:51 -0700 Evan Martin * configure.ac, autogen.sh, Makefile.am: Use autotools. * items.c, memcached.c: #include for time(), printf time_t as %lu (is this correct?), minor warnings fixes. memcached-1.6.20/crawler.h0000664000175000017500000000245114204760331012243 00000000000000#ifndef CRAWLER_H #define CRAWLER_H #define LRU_CRAWLER_CAP_REMAINING -1 typedef struct { uint64_t histo[61]; uint64_t ttl_hourplus; uint64_t noexp; uint64_t reclaimed; uint64_t seen; rel_time_t start_time; rel_time_t end_time; bool run_complete; } crawlerstats_t; struct crawler_expired_data { pthread_mutex_t lock; crawlerstats_t crawlerstats[POWER_LARGEST]; /* redundant with crawlerstats_t so we can get overall start/stop/done */ rel_time_t start_time; rel_time_t end_time; bool crawl_complete; bool is_external; /* whether this was an alloc local or remote to the module. */ }; enum crawler_result_type { CRAWLER_OK=0, CRAWLER_RUNNING, CRAWLER_BADCLASS, CRAWLER_NOTSTARTED, CRAWLER_ERROR }; int start_item_crawler_thread(void); #define CRAWLER_WAIT true #define CRAWLER_NOWAIT false int stop_item_crawler_thread(bool wait); int init_lru_crawler(void *arg); enum crawler_result_type lru_crawler_crawl(char *slabs, enum crawler_run_type, void *c, const int sfd, unsigned int remaining); int lru_crawler_start(uint8_t *ids, uint32_t remaining, const enum crawler_run_type type, void *data, void *c, const int sfd); void lru_crawler_pause(void); void lru_crawler_resume(void); #endif memcached-1.6.20/proxy_config.c0000664000175000017500000004202614427543277013326 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ // Functions related to the configuration management threads and VM // TODO (v2): move worker thread related code back out of here. #include "proxy.h" struct _dumpbuf { size_t size; size_t used; char *buf; }; static int _dump_helper(lua_State *L, const void *p, size_t sz, void *ud) { (void)L; struct _dumpbuf *db = ud; if (db->used + sz > db->size) { db->size *= 2; char *nb = realloc(db->buf, db->size); if (nb == NULL) { return -1; } db->buf = nb; } memcpy(db->buf + db->used, (const char *)p, sz); db->used += sz; return 0; } static const char * _load_helper(lua_State *L, void *data, size_t *size) { (void)L; struct _dumpbuf *db = data; if (db->used == 0) { *size = 0; return NULL; } *size = db->used; db->used = 0; return db->buf; } void proxy_start_reload(void *arg) { proxy_ctx_t *ctx = arg; if (pthread_mutex_trylock(&ctx->config_lock) == 0) { ctx->loading = true; pthread_cond_signal(&ctx->config_cond); pthread_mutex_unlock(&ctx->config_lock); } } int proxy_first_confload(void *arg) { proxy_ctx_t *ctx = arg; pthread_mutex_lock(&ctx->config_lock); ctx->loading = true; pthread_cond_signal(&ctx->config_cond); pthread_mutex_unlock(&ctx->config_lock); while (1) { bool stop = false; pthread_mutex_lock(&ctx->config_lock); if (!ctx->loading) { stop = true; } pthread_mutex_unlock(&ctx->config_lock); if (stop) break; } int fails = 0; STAT_L(ctx); fails = ctx->global_stats.config_reload_fails; STAT_UL(ctx); if (fails) { return -1; } return 0; } // Manages a queue of inbound objects destined to be deallocated. static void *_proxy_manager_thread(void *arg) { proxy_ctx_t *ctx = arg; pool_head_t head; pthread_mutex_lock(&ctx->manager_lock); while (1) { STAILQ_INIT(&head); while (STAILQ_EMPTY(&ctx->manager_head)) { pthread_cond_wait(&ctx->manager_cond, &ctx->manager_lock); } // pull dealloc queue into local queue. STAILQ_CONCAT(&head, &ctx->manager_head); pthread_mutex_unlock(&ctx->manager_lock); // Config lock is required for using config VM. pthread_mutex_lock(&ctx->config_lock); lua_State *L = ctx->proxy_state; mcp_pool_t *p; STAILQ_FOREACH(p, &head, next) { // we let the pool object _gc() handle backend references. luaL_unref(L, LUA_REGISTRYINDEX, p->phc_ref); // need to... unref self. // NOTE: double check if we really need to self-reference. // this is a backup here to ensure the external refcounts hit zero // before lua garbage collects the object. other things hold a // reference to the object though. luaL_unref(L, LUA_REGISTRYINDEX, p->self_ref); } pthread_mutex_unlock(&ctx->config_lock); // force lua garbage collection so any resources close out quickly. lua_gc(L, LUA_GCCOLLECT); // twice because objects with garbage collector handlers are only // marked on the first collection cycle. lua_gc(L, LUA_GCCOLLECT); // done. pthread_mutex_lock(&ctx->manager_lock); } return NULL; } // Thread handling the configuration reload sequence. // TODO (v2): get a logger instance. // TODO (v2): making this "safer" will require a few phases of work. // 1) JFDI // 2) "test VM" -> from config thread, test the worker reload portion. // 3) "unit testing" -> from same temporary worker VM, execute set of // integration tests that must pass. // 4) run update on each worker, collecting new mcp.attach() hooks. // Once every worker has successfully executed and set new hooks, roll // through a _second_ time to actually swap the hook structures and unref // the old structures where marked dirty. static void *_proxy_config_thread(void *arg) { proxy_ctx_t *ctx = arg; logger_create(); pthread_mutex_lock(&ctx->config_lock); while (1) { ctx->loading = false; pthread_cond_wait(&ctx->config_cond, &ctx->config_lock); LOGGER_LOG(NULL, LOG_PROXYEVENTS, LOGGER_PROXY_CONFIG, NULL, "start"); STAT_INCR(ctx, config_reloads, 1); lua_State *L = ctx->proxy_state; lua_settop(L, 0); // clear off any crud that could have been left on the stack. // The main stages of config reload are: // - load and execute the config file // - run mcp_config_pools() // - for each worker: // - copy and execute new lua code // - copy selector table // - run mcp_config_routes() if (proxy_load_config(ctx) != 0) { // Failed to load. log and wait for a retry. STAT_INCR(ctx, config_reload_fails, 1); LOGGER_LOG(NULL, LOG_PROXYEVENTS, LOGGER_PROXY_CONFIG, NULL, "failed"); continue; } // TODO (v2): create a temporary VM to test-load the worker code into. // failing to load partway through the worker VM reloads can be // critically bad if we're not careful about references. // IE: the config VM _must_ hold references to selectors and backends // as long as they exist in any worker for any reason. for (int x = 0; x < settings.num_threads; x++) { LIBEVENT_THREAD *thr = get_worker_thread(x); pthread_mutex_lock(&ctx->worker_lock); ctx->worker_done = false; ctx->worker_failed = false; proxy_reload_notify(thr); while (!ctx->worker_done) { // in case of spurious wakeup. pthread_cond_wait(&ctx->worker_cond, &ctx->worker_lock); } pthread_mutex_unlock(&ctx->worker_lock); // Code load bailed. if (ctx->worker_failed) { STAT_INCR(ctx, config_reload_fails, 1); LOGGER_LOG(NULL, LOG_PROXYEVENTS, LOGGER_PROXY_CONFIG, NULL, "failed"); continue; } } LOGGER_LOG(NULL, LOG_PROXYEVENTS, LOGGER_PROXY_CONFIG, NULL, "done"); } return NULL; } int _start_proxy_config_threads(proxy_ctx_t *ctx) { int ret; pthread_mutex_lock(&ctx->config_lock); if ((ret = pthread_create(&ctx->config_tid, NULL, _proxy_config_thread, ctx)) != 0) { fprintf(stderr, "Failed to start proxy configuration thread: %s\n", strerror(ret)); pthread_mutex_unlock(&ctx->config_lock); return -1; } thread_setname(ctx->config_tid, "mc-prx-config"); pthread_mutex_unlock(&ctx->config_lock); pthread_mutex_lock(&ctx->manager_lock); if ((ret = pthread_create(&ctx->manager_tid, NULL, _proxy_manager_thread, ctx)) != 0) { fprintf(stderr, "Failed to start proxy manager thread: %s\n", strerror(ret)); pthread_mutex_unlock(&ctx->manager_lock); return -1; } thread_setname(ctx->manager_tid, "mc-prx-manager"); pthread_mutex_unlock(&ctx->manager_lock); return 0; } int proxy_load_config(void *arg) { proxy_ctx_t *ctx = arg; lua_State *L = ctx->proxy_state; int res = luaL_loadfile(L, settings.proxy_startfile); if (res != LUA_OK) { fprintf(stderr, "ERROR: Failed to load proxy_startfile: %s\n", lua_tostring(L, -1)); return -1; } // LUA_OK, LUA_ERRSYNTAX, LUA_ERRMEM, LUA_ERRFILE // Now we need to dump the compiled code into bytecode. // This will then get loaded into worker threads. struct _dumpbuf *db = malloc(sizeof(struct _dumpbuf)); db->size = 16384; db->used = 0; db->buf = malloc(db->size); lua_dump(L, _dump_helper, db, 0); // 0 means no error. ctx->proxy_code = db; // now we complete the data load by calling the function. res = lua_pcall(L, 0, LUA_MULTRET, 0); if (res != LUA_OK) { fprintf(stderr, "ERROR: Failed to load data into lua config state: %s\n", lua_tostring(L, -1)); exit(EXIT_FAILURE); } // call the mcp_config_pools function to get the central backends. lua_getglobal(L, "mcp_config_pools"); if (lua_isnil(L, -1)) { fprintf(stderr, "ERROR: Configuration file missing 'mcp_config_pools' function\n"); exit(EXIT_FAILURE); } lua_pushnil(L); // no "old" config yet. if (lua_pcall(L, 1, 1, 0) != LUA_OK) { fprintf(stderr, "ERROR: Failed to execute mcp_config_pools: %s\n", lua_tostring(L, -1)); exit(EXIT_FAILURE); } // result is our main config. return 0; } static int _copy_pool(lua_State *from, lua_State *to, LIBEVENT_THREAD *thr) { // from, -3 should have he userdata. mcp_pool_t *p = luaL_checkudata(from, -3, "mcp.pool"); size_t size = sizeof(mcp_pool_proxy_t); mcp_pool_proxy_t *pp = lua_newuserdatauv(to, size, 0); luaL_setmetatable(to, "mcp.pool_proxy"); pp->main = p; if (p->use_iothread) { pp->pool = p->pool; } else { // allow 0 indexing for backends when unique to each worker thread pp->pool = &p->pool[thr->thread_baseid * p->pool_size]; } pthread_mutex_lock(&p->lock); p->refcount++; pthread_mutex_unlock(&p->lock); return 0; } static void _copy_config_table(lua_State *from, lua_State *to, LIBEVENT_THREAD *thr); // (from, -1) is the source value // should end with (to, -1) being the new value. static void _copy_config_table(lua_State *from, lua_State *to, LIBEVENT_THREAD *thr) { int type = lua_type(from, -1); bool found = false; luaL_checkstack(from, 4, "configuration error: table recursion too deep"); luaL_checkstack(to, 4, "configuration error: table recursion too deep"); switch (type) { case LUA_TNIL: lua_pushnil(to); break; case LUA_TUSERDATA: // see dump_stack() - check if it's something we handle. if (lua_getmetatable(from, -1) != 0) { lua_pushstring(from, "__name"); if (lua_rawget(from, -2) != LUA_TNIL) { const char *name = lua_tostring(from, -1); if (strcmp(name, "mcp.pool") == 0) { _copy_pool(from, to, thr); found = true; } } lua_pop(from, 2); } if (!found) { proxy_lua_ferror(from, "unhandled userdata type in configuration table\n"); } break; case LUA_TNUMBER: if (lua_isinteger(from, -1)) { lua_pushinteger(to, lua_tointeger(from, -1)); } else { lua_pushnumber(to, lua_tonumber(from, -1)); } break; case LUA_TSTRING: lua_pushlstring(to, lua_tostring(from, -1), lua_rawlen(from, -1)); break; case LUA_TBOOLEAN: lua_pushboolean(to, lua_toboolean(from, -1)); break; case LUA_TTABLE: // TODO (v2): copy the metatable first? // TODO (v2): size narr/nrec from old table and use createtable to // pre-allocate. lua_newtable(to); // throw new table on worker int t = lua_absindex(from, -1); // static index of table to copy. int nt = lua_absindex(to, -1); // static index of new table. lua_pushnil(from); // start iterator for main while (lua_next(from, t) != 0) { // (key, -2), (val, -1) int keytype = lua_type(from, -2); // to intentionally limit complexity and allow for future // optimizations we restrict what types may be used as keys // for sub-tables. switch (keytype) { case LUA_TSTRING: // to[l]string converts the actual key in the table // into a string, so we must not do that unless it // already is one. lua_pushlstring(to, lua_tostring(from, -2), lua_rawlen(from, -2)); break; case LUA_TNUMBER: if (lua_isinteger(from, -2)) { lua_pushinteger(to, lua_tointeger(from, -2)); } else { lua_pushnumber(to, lua_tonumber(from, -2)); } break; default: proxy_lua_error(from, "configuration table keys must be strings or numbers"); } // lua_settable(to, n) - n being the table // takes -2 key -1 value, pops both. // use lua_absindex(L, -1) and so to convert easier? _copy_config_table(from, to, thr); // push next value. lua_settable(to, nt); lua_pop(from, 1); // drop value, keep key. } // top of from is now the original table. // top of to should be the new table. break; default: proxy_lua_error(from, "unhandled data type in configuration table\n"); } } // Run from proxy worker to coordinate code reload. // config_lock must be held first. void proxy_worker_reload(void *arg, LIBEVENT_THREAD *thr) { proxy_ctx_t *ctx = arg; pthread_mutex_lock(&ctx->worker_lock); if (proxy_thread_loadconf(ctx, thr) != 0) { ctx->worker_failed = true; } ctx->worker_done = true; pthread_cond_signal(&ctx->worker_cond); pthread_mutex_unlock(&ctx->worker_lock); } // FIXME (v2): need to test how to recover from an actual error here. error message // needs to go somewhere useful, counters added, etc. int proxy_thread_loadconf(proxy_ctx_t *ctx, LIBEVENT_THREAD *thr) { lua_State *L = thr->L; // load the precompiled config function. struct _dumpbuf *db = ctx->proxy_code; struct _dumpbuf db2; // copy because the helper modifies it. memcpy(&db2, db, sizeof(struct _dumpbuf)); lua_load(L, _load_helper, &db2, "config", NULL); // LUA_OK + all errs from loadfile except LUA_ERRFILE. //dump_stack(L); // - pcall the func (which should load it) int res = lua_pcall(L, 0, LUA_MULTRET, 0); if (res != LUA_OK) { // FIXME (v2): don't exit here! fprintf(stderr, "Failed to load data into worker thread: %s\n", lua_tostring(L, -1)); return -1; } lua_getglobal(L, "mcp_config_routes"); // create deepcopy of argument to pass into mcp_config_routes. // FIXME (v2): to avoid lua SIGABRT'ing on errors we need to protect the call // normal pattern: // lua_pushcfunction(L, &_copy_config_table); // lua_pushlightuserdata(L, &L2); // res = la_pcall(L, etc); // ... but since this is cross-VM we could get errors from not the // protected VM, breaking setjmp/etc. // for this part of the code we should override lua_atpanic(), // allowing us to specifically recover and bail. // However, again, this will require the next version of the config reload // code since we are re-using the VM's and a panic can leave us in a // broken state. // If the setjump/longjump combos are compatible a pcall for from and // atpanic for to might work best, since the config VM is/should be long // running and worker VM's should be rotated. _copy_config_table(ctx->proxy_state, L, thr); // copied value is in front of route function, now call it. if (lua_pcall(L, 1, 1, 0) != LUA_OK) { fprintf(stderr, "Failed to execute mcp_config_routes: %s\n", lua_tostring(L, -1)); return -1; } // update user stats STAT_L(ctx); struct proxy_user_stats *us = &ctx->user_stats; struct proxy_user_stats *tus = NULL; if (us->num_stats != 0) { pthread_mutex_lock(&thr->stats.mutex); if (thr->proxy_user_stats == NULL) { tus = calloc(1, sizeof(struct proxy_user_stats)); thr->proxy_user_stats = tus; } else { tus = thr->proxy_user_stats; } // originally this was a realloc routine but it felt fragile. // that might still be a better idea; still need to zero out the end. uint64_t *counters = calloc(us->num_stats, sizeof(uint64_t)); // note that num_stats can _only_ grow in size. // we also only care about counters on the worker threads. if (tus->counters) { assert(tus->num_stats <= us->num_stats); memcpy(counters, tus->counters, tus->num_stats * sizeof(uint64_t)); free(tus->counters); } tus->counters = counters; tus->num_stats = us->num_stats; pthread_mutex_unlock(&thr->stats.mutex); } // also grab the concurrent request limit thr->proxy_active_req_limit = ctx->active_req_limit; STAT_UL(ctx); // update limit counter(s) pthread_mutex_lock(&thr->proxy_limit_lock); thr->proxy_buffer_memory_limit = ctx->buffer_memory_limit; pthread_mutex_unlock(&thr->proxy_limit_lock); return 0; } memcached-1.6.20/proxy_xxhash.c0000664000175000017500000000044514340006077013345 00000000000000/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */ #include "proxy.h" static struct proxy_hash_func mcplib_hash_xxhash = { XXH3_64bits_withSeed, }; int mcplib_open_hash_xxhash(lua_State *L) { lua_pushlightuserdata(L, &mcplib_hash_xxhash); return 1; } memcached-1.6.20/freebsd_priv.c0000664000175000017500000000254214204760331013252 00000000000000#include #include #include #include #include #include #include "memcached.h" /* * dropping privileges is entering in capability mode * in FreeBSD vocabulary. */ void drop_privileges() { cap_rights_t wd, rd; if (cap_rights_init(&wd, CAP_WRITE, CAP_READ) == NULL) { fprintf(stderr, "cap_rights_init write protection failed: %s\n", strerror(errno)); exit(EXIT_FAILURE); } if (cap_rights_init(&rd, CAP_FCNTL, CAP_READ, CAP_EVENT) == NULL) { fprintf(stderr, "cap_rights_init read protection failed: %s\n", strerror(errno)); exit(EXIT_FAILURE); } if (cap_rights_limit(STDIN_FILENO, &rd) != 0) { fprintf(stderr, "cap_rights_limit stdin failed: %s\n", strerror(errno)); exit(EXIT_FAILURE); } if (cap_rights_limit(STDOUT_FILENO, &wd) != 0) { fprintf(stderr, "cap_rights_limit stdout failed: %s\n", strerror(errno)); exit(EXIT_FAILURE); } if (cap_rights_limit(STDERR_FILENO, &wd) != 0) { fprintf(stderr, "cap_rights_limit stderr failed: %s\n", strerror(errno)); exit(EXIT_FAILURE); } if (cap_enter() != 0) { fprintf(stderr, "cap_enter failed: %s\n", strerror(errno)); exit(EXIT_FAILURE); } } void setup_privilege_violations_handler(void) { // not needed } memcached-1.6.20/linux_priv.c0000664000175000017500000002224314340006077013000 00000000000000#include "config.h" #include #include #include #include #include #include #include #include "memcached.h" static char *kill_msg; // Make sure to preserve the ??? position in the string, or correct the offsets // in the syssig handler. #define KILL_MSG_STR "Seccomp policy failure. Caught syscall ???. This is " \ "either an exploit attempt, or your system is not supported yet.\n" static void handle_syssig(int signum, siginfo_t *si, void *thread_context) { #if defined(si_syscall) int syscall_no = si->si_syscall; #else // If system has no support for si_syscal, the information may not be // precise. int syscall_no = si->si_value.sival_int; #endif // Replace the characters in the kill message with the syscall number. We // can't safely printf (even write is not really valid, but we're crashing // anyway). kill_msg[39] = (syscall_no / 100) % 10 + '0'; kill_msg[40] = (syscall_no / 10) % 10 + '0'; kill_msg[41] = syscall_no % 10 + '0'; if (write(2, kill_msg, strlen(kill_msg)) == -1) { // An error occurred, but we can't do anything about it here. This check // is mostly to avoid the "ignoring return value of 'write'" error on // distributions with broken gcc (no "ignore via cast to void" support). } // We can't use the nice exit() version because it causes at_exit handlers // to be looked up and run. We can't take any locks while handling the // signal, so _exit() is the only thing to do safely. _exit(EXIT_FAILURE); } static const struct sigaction act = { .sa_sigaction = handle_syssig, .sa_flags = SA_SIGINFO, }; void setup_privilege_violations_handler(void) { kill_msg = malloc(strlen(KILL_MSG_STR)+1); strncpy(kill_msg, KILL_MSG_STR, strlen(KILL_MSG_STR)+1); sigaction(SIGSYS, &act, NULL); } // If anything crosses the policy, kill the process. #define DENY_ACTION SCMP_ACT_TRAP void drop_privileges(void) { scmp_filter_ctx ctx = seccomp_init(DENY_ACTION); if (ctx == NULL) { return; } int rc = 0; rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(sigreturn), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigreturn), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigprocmask), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigaction), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(futex), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(epoll_wait), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(epoll_pwait), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(epoll_ctl), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(accept4), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(accept), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(writev), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fstat), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(close), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mmap), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(munmap), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(shmctl), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(ioctl), 1, SCMP_A1(SCMP_CMP_EQ, TIOCGWINSZ)); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(ioctl), 1, SCMP_A1(SCMP_CMP_EQ, TCGETS)); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(msync), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(umask), 0); #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(clock_gettime), 0); #endif rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(gettimeofday), 0); #ifdef MEMCACHED_DEBUG rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(open), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fcntl), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(readv), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(lseek), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpid), 0); if (settings.relaxed_privileges) { rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(openat), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mkdir), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(access), 0); } #endif if (rc != 0) { goto fail; } rc = seccomp_load(ctx); if (rc < 0) { goto fail; } seccomp_release(ctx); return; fail: seccomp_release(ctx); fprintf(stderr, "Failed to set a seccomp profile on the main thread\n"); exit(EXIT_FAILURE); } void drop_worker_privileges(void) { scmp_filter_ctx ctx = seccomp_init(DENY_ACTION); if (ctx == NULL) { return; } int rc = 0; rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(sigreturn), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigreturn), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigprocmask), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigaction), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(futex), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(epoll_wait), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(epoll_pwait), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(epoll_ctl), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(poll), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(readv), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mprotect), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpeername), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(close), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(sendmsg), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getrusage), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mmap), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mremap), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(munmap), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(recvfrom), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(ioctl), 1, SCMP_A1(SCMP_CMP_EQ, TIOCGWINSZ)); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(msync), 0); // for spawning the LRU crawler rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(clone), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(set_robust_list), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(madvise), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit), 0); // stat rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getsockname), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpid), 0); if (settings.shutdown_command) { rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(tgkill), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(tkill), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fstat), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpid), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(gettid), 0); } if (settings.relaxed_privileges) { rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(openat), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mkdir), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(access), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(open), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fcntl), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(lseek), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(writev), 0); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(socket), 0); } else { // stdout rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 1, SCMP_A0(SCMP_CMP_EQ, 1)); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(writev), 1, SCMP_A0(SCMP_CMP_EQ, 1)); // stderr rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 1, SCMP_A0(SCMP_CMP_EQ, 2)); rc |= seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(writev), 1, SCMP_A0(SCMP_CMP_EQ, 2)); } if (rc != 0) { goto fail; } rc = seccomp_load(ctx); if (rc < 0) { goto fail; } seccomp_release(ctx); return; fail: seccomp_release(ctx); fprintf(stderr, "Failed to set a seccomp profile on a worker thread\n"); exit(EXIT_FAILURE); } memcached-1.6.20/base64.c0000664000175000017500000001511614302037501011660 00000000000000/* * Base64 encoding/decoding (RFC1341) * Copyright (c) 2005-2011, Jouni Malinen * Modified by Dormando * * This software may be distributed under the terms of the BSD license. * Original license included below: * License ------- This software may be distributed, used, and modified under the terms of BSD license: Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name(s) of the above-listed copyright holder(s) nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* Changes from original code: * - decode table is pre-generated * - no line splitting on encoder * - output buffers are passed in instead of malloc'ed * - returns encoded/decoded length instead of pointer. */ #include #include "base64.h" static const unsigned char base64_table[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; /* Original decode function generated the table every time. I used the code to * print this table and pre-generate it instead. */ static const unsigned char dtable[256] = { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 0, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 }; /** * base64_encode - Base64 encode * @src: Data to be encoded * @len: Length of the data to be encoded * @out: output uffer * @out_len: length of output buffer * Returns: Number of actual bytes encoded into the buffer * or 0 on failure * * Output buffer is nul terminated to make it easier to use as a C string. * The nul terminator is * not included in the return length. */ size_t base64_encode(const unsigned char *src, size_t len, unsigned char *out, size_t out_len) { unsigned char *pos; const unsigned char *end, *in; size_t olen; olen = len * 4 / 3 + 4; /* 3-byte blocks to 4-byte */ olen += olen / 72; /* line feeds */ olen++; /* nul termination */ if (olen < len) { return 0; /* integer overflow */ } if (olen > out_len) { return 0; /* not enough space in output buffer */ } if (out == NULL) { return 0; } end = src + len; in = src; pos = out; while (end - in >= 3) { *pos++ = base64_table[in[0] >> 2]; *pos++ = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)]; *pos++ = base64_table[((in[1] & 0x0f) << 2) | (in[2] >> 6)]; *pos++ = base64_table[in[2] & 0x3f]; in += 3; } if (end - in) { *pos++ = base64_table[in[0] >> 2]; if (end - in == 1) { *pos++ = base64_table[(in[0] & 0x03) << 4]; *pos++ = '='; } else { *pos++ = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)]; *pos++ = base64_table[(in[1] & 0x0f) << 2]; } *pos++ = '='; } *pos = '\0'; return pos - out; } /** * base64_decode - Base64 decode * @src: Data to be decoded * @len: Length of the data to be decoded * @out: Output buffer to decode into * @out_len: Length of output buffer * Returns: Length of encoded data, or 0 on failure */ size_t base64_decode(const unsigned char *src, size_t len, unsigned char *out, size_t out_len) { unsigned char *pos, block[4], tmp; size_t i, count, olen; int pad = 0; count = 0; for (i = 0; i < len; i++) { if (dtable[src[i]] != 0x80) count++; } if (count == 0 || count % 4) return 0; olen = count / 4 * 3; if (olen > out_len) { return 0; } pos = out; if (out == NULL) { return 0; } count = 0; for (i = 0; i < len; i++) { tmp = dtable[src[i]]; if (tmp == 0x80) continue; if (src[i] == '=') pad++; block[count] = tmp; count++; if (count == 4) { *pos++ = (block[0] << 2) | (block[1] >> 4); *pos++ = (block[1] << 4) | (block[2] >> 2); *pos++ = (block[2] << 6) | block[3]; count = 0; if (pad) { if (pad == 1) pos--; else if (pad == 2) pos -= 2; else { /* Invalid padding */ return 0; } break; } } } return pos - out; } memcached-1.6.20/md5.h0000664000175000017500000000667414340006077011305 00000000000000/* Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved. This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. L. Peter Deutsch ghost@aladdin.com */ /* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */ /* Independent implementation of MD5 (RFC 1321). This code implements the MD5 Algorithm defined in RFC 1321, whose text is available at http://www.ietf.org/rfc/rfc1321.txt The code is derived from the text of the RFC, including the test suite (section A.5) but excluding the rest of Appendix A. It does not include any code or documentation that is identified in the RFC as being copyrighted. The original and principal author of md5.h is L. Peter Deutsch . Other authors are noted in the change history that follows (in reverse chronological order): 2002-04-13 lpd Removed support for non-ANSI compilers; removed references to Ghostscript; clarified derivation from RFC 1321; now handles byte order either statically or dynamically. 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5); added conditionalization for C++ compilation from Martin Purschke . 1999-05-03 lpd Original version. */ #ifndef md5_INCLUDED # define md5_INCLUDED /* * This package supports both compile-time and run-time determination of CPU * byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is * defined as non-zero, the code will be compiled to run only on big-endian * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to * run on either big- or little-endian CPUs, but will run slightly less * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined. */ typedef unsigned char md5_byte_t; /* 8-bit byte */ typedef unsigned int md5_word_t; /* 32-bit word */ /* Define the state of the MD5 Algorithm. */ typedef struct md5_state_s { md5_word_t count[2]; /* message length in bits, lsw first */ md5_word_t abcd[4]; /* digest buffer */ md5_byte_t buf[64]; /* accumulate block */ } md5_state_t; #ifdef __cplusplus extern "C" { #endif /* Initialize the algorithm. */ #ifdef WIN32 _declspec(dllexport) #endif void md5_init(md5_state_t *pms); /* Append a string to the message. */ #ifdef WIN32 _declspec(dllexport) #endif void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes); /* Finish the message and return the digest. */ #ifdef WIN32 _declspec(dllexport) #endif void md5_finish(md5_state_t *pms, md5_byte_t digest[16]); #ifdef __cplusplus } /* end extern "C" */ #endif #endif /* md5_INCLUDED */ memcached-1.6.20/doc/0000755000175000017500000000000014427544305011264 500000000000000memcached-1.6.20/doc/Makefile0000664000175000017500000003760414427544305012660 00000000000000# Makefile.in generated by automake 1.16.5 from Makefile.am. # doc/Makefile. Generated from Makefile.in by configure. # Copyright (C) 1994-2021 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. am__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) pkgdatadir = $(datadir)/memcached pkgincludedir = $(includedir)/memcached pkglibdir = $(libdir)/memcached pkglibexecdir = $(libexecdir)/memcached am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd install_sh_DATA = $(install_sh) -c -m 644 install_sh_PROGRAM = $(install_sh) -c install_sh_SCRIPT = $(install_sh) -c INSTALL_HEADER = $(INSTALL_DATA) transform = $(program_transform_name) NORMAL_INSTALL = : PRE_INSTALL = : POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : build_triplet = x86_64-pc-linux-gnu host_triplet = x86_64-pc-linux-gnu subdir = doc ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/version.m4 \ $(top_srcdir)/m4/c99-backport.m4 $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = AM_V_P = $(am__v_P_$(V)) am__v_P_ = $(am__v_P_$(AM_DEFAULT_VERBOSITY)) am__v_P_0 = false am__v_P_1 = : AM_V_GEN = $(am__v_GEN_$(V)) am__v_GEN_ = $(am__v_GEN_$(AM_DEFAULT_VERBOSITY)) am__v_GEN_0 = @echo " GEN " $@; am__v_GEN_1 = AM_V_at = $(am__v_at_$(V)) am__v_at_ = $(am__v_at_$(AM_DEFAULT_VERBOSITY)) am__v_at_0 = @ am__v_at_1 = SOURCES = DIST_SOURCES = am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; am__vpath_adj = case $$p in \ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ *) f=$$p;; \ esac; am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; am__install_max = 40 am__nobase_strip_setup = \ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` am__nobase_strip = \ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" am__nobase_list = $(am__nobase_strip_setup); \ for p in $$list; do echo "$$p $$p"; done | \ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ if (++n[$$2] == $(am__install_max)) \ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ END { for (dir in files) print dir, files[dir] }' am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' am__uninstall_files_from_dir = { \ test -z "$$files" \ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ $(am__cd) "$$dir" && rm -f $$files; }; \ } man1dir = $(mandir)/man1 am__installdirs = "$(DESTDIR)$(man1dir)" NROFF = nroff MANS = $(man_MANS) am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) am__DIST_COMMON = $(srcdir)/Makefile.in DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ACLOCAL = ${SHELL} '/home/dormando/p/code/memcached/missing' aclocal-1.16 AMTAR = $${TAR-tar} AM_DEFAULT_VERBOSITY = 1 AUTOCONF = ${SHELL} '/home/dormando/p/code/memcached/missing' autoconf AUTOHEADER = ${SHELL} '/home/dormando/p/code/memcached/missing' autoheader AUTOMAKE = ${SHELL} '/home/dormando/p/code/memcached/missing' automake-1.16 AWK = mawk CC = gcc CCDEPMODE = depmode=gcc3 CFLAGS = -g -O2 -pthread -pthread -Wall -pedantic -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls CPP = gcc -E CPPFLAGS = CSCOPE = cscope CTAGS = ctags CYGPATH_W = echo DEFS = -DHAVE_CONFIG_H DEPDIR = .deps DTRACE = DTRACEFLAGS = ECHO_C = ECHO_N = -n ECHO_T = EGREP = /usr/bin/grep -E ENABLE_SASL = ETAGS = etags EXEEXT = GREP = /usr/bin/grep INSTALL = /usr/bin/install -c INSTALL_DATA = ${INSTALL} -m 644 INSTALL_PROGRAM = ${INSTALL} INSTALL_SCRIPT = ${INSTALL} INSTALL_STRIP_PROGRAM = $(install_sh) -c -s LDFLAGS = LIBOBJS = LIBS = -levent LTLIBOBJS = MAKEINFO = ${SHELL} '/home/dormando/p/code/memcached/missing' makeinfo MKDIR_P = /usr/bin/mkdir -p OBJEXT = o OPENSSL_CFLAGS = OPENSSL_LIBS = PACKAGE = memcached PACKAGE_BUGREPORT = memcached@googlegroups.com PACKAGE_NAME = memcached PACKAGE_STRING = memcached 1.6.20 PACKAGE_TARNAME = memcached PACKAGE_URL = PACKAGE_VERSION = 1.6.20 PATH_SEPARATOR = : PKG_CONFIG = /usr/bin/pkg-config PKG_CONFIG_LIBDIR = PKG_CONFIG_PATH = PROFILER = /usr/bin/gcov PROFILER_FLAGS = -fprofile-arcs -ftest-coverage PROFILER_LDFLAGS = -lgcov SET_MAKE = SHELL = /bin/bash STRIP = VERSION = 1.6.20 XML2RFC = no XSLTPROC = no abs_builddir = /home/dormando/p/code/memcached/doc abs_srcdir = /home/dormando/p/code/memcached/doc abs_top_builddir = /home/dormando/p/code/memcached abs_top_srcdir = /home/dormando/p/code/memcached ac_ct_CC = gcc am__include = include am__leading_dot = . am__quote = am__tar = $${TAR-tar} chof - "$$tardir" am__untar = $${TAR-tar} xf - bindir = ${exec_prefix}/bin build = x86_64-pc-linux-gnu build_alias = build_cpu = x86_64 build_os = linux-gnu build_vendor = pc builddir = . datadir = ${datarootdir} datarootdir = ${prefix}/share docdir = ${datarootdir}/doc/${PACKAGE_TARNAME} dvidir = ${docdir} exec_prefix = ${prefix} host = x86_64-pc-linux-gnu host_alias = host_cpu = x86_64 host_os = linux-gnu host_vendor = pc htmldir = ${docdir} includedir = ${prefix}/include infodir = ${datarootdir}/info install_sh = ${SHELL} /home/dormando/p/code/memcached/install-sh libdir = ${exec_prefix}/lib libexecdir = ${exec_prefix}/libexec localedir = ${datarootdir}/locale localstatedir = ${prefix}/var mandir = ${datarootdir}/man mkdir_p = $(MKDIR_P) oldincludedir = /usr/include pdfdir = ${docdir} prefix = /usr/local program_transform_name = s,x,x, psdir = ${docdir} runstatedir = ${localstatedir}/run sbindir = ${exec_prefix}/sbin sharedstatedir = ${prefix}/com srcdir = . sysconfdir = ${prefix}/etc target_alias = top_build_prefix = ../ top_builddir = .. top_srcdir = .. man_MANS = memcached.1 SPECIFICATIONS = protocol-binary.txt protocol-binary-range.txt # When we make dist always include the generated specifications so people don't # have to have xml2rfc and xsltproc installed EXTRA_DIST = $(srcdir)/*.txt $(SPECIFICATIONS) BUILT_SOURCES = MOSTLYCLEANFILES = all: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) all-am .SUFFIXES: $(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ && { if test -f $@; then exit 0; else break; fi; }; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign doc/Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign doc/Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(top_srcdir)/configure: $(am__configure_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(ACLOCAL_M4): $(am__aclocal_m4_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): install-man1: $(man_MANS) @$(NORMAL_INSTALL) @list1=''; \ list2='$(man_MANS)'; \ test -n "$(man1dir)" \ && test -n "`echo $$list1$$list2`" \ || exit 0; \ echo " $(MKDIR_P) '$(DESTDIR)$(man1dir)'"; \ $(MKDIR_P) "$(DESTDIR)$(man1dir)" || exit 1; \ { for i in $$list1; do echo "$$i"; done; \ if test -n "$$list2"; then \ for i in $$list2; do echo "$$i"; done \ | sed -n '/\.1[a-z]*$$/p'; \ fi; \ } | while read p; do \ if test -f $$p; then d=; else d="$(srcdir)/"; fi; \ echo "$$d$$p"; echo "$$p"; \ done | \ sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \ -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \ sed 'N;N;s,\n, ,g' | { \ list=; while read file base inst; do \ if test "$$base" = "$$inst"; then list="$$list $$file"; else \ echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man1dir)/$$inst'"; \ $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man1dir)/$$inst" || exit $$?; \ fi; \ done; \ for i in $$list; do echo "$$i"; done | $(am__base_list) | \ while read files; do \ test -z "$$files" || { \ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man1dir)'"; \ $(INSTALL_DATA) $$files "$(DESTDIR)$(man1dir)" || exit $$?; }; \ done; } uninstall-man1: @$(NORMAL_UNINSTALL) @list=''; test -n "$(man1dir)" || exit 0; \ files=`{ for i in $$list; do echo "$$i"; done; \ l2='$(man_MANS)'; for i in $$l2; do echo "$$i"; done | \ sed -n '/\.1[a-z]*$$/p'; \ } | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \ -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \ dir='$(DESTDIR)$(man1dir)'; $(am__uninstall_files_from_dir) tags TAGS: ctags CTAGS: cscope cscopelist: distdir: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(DISTFILES) @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ list='$(DISTFILES)'; \ dist_files=`for file in $$list; do echo $$file; done | \ sed -e "s|^$$srcdirstrip/||;t" \ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ case $$dist_files in \ */*) $(MKDIR_P) `echo "$$dist_files" | \ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ sort -u` ;; \ esac; \ for file in $$dist_files; do \ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ if test -d $$d/$$file; then \ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ if test -d "$(distdir)/$$file"; then \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ else \ test -f "$(distdir)/$$file" \ || cp -p $$d/$$file "$(distdir)/$$file" \ || exit 1; \ fi; \ done check-am: all-am check: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) check-am all-am: Makefile $(MANS) installdirs: for dir in "$(DESTDIR)$(man1dir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) install-am install-exec: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data: install-data-am uninstall: uninstall-am install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-am install-strip: if test -z '$(STRIP)'; then \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ install; \ else \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ fi mostlyclean-generic: -test -z "$(MOSTLYCLEANFILES)" || rm -f $(MOSTLYCLEANFILES) clean-generic: distclean-generic: -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." -test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES) clean: clean-am clean-am: clean-generic mostlyclean-am distclean: distclean-am -rm -f Makefile distclean-am: clean-am distclean-generic dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-man install-dvi: install-dvi-am install-dvi-am: install-exec-am: install-html: install-html-am install-html-am: install-info: install-info-am install-info-am: install-man: install-man1 install-pdf: install-pdf-am install-pdf-am: install-ps: install-ps-am install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-am -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-am mostlyclean-am: mostlyclean-generic pdf: pdf-am pdf-am: ps: ps-am ps-am: uninstall-am: uninstall-man uninstall-man: uninstall-man1 .MAKE: all check install install-am install-exec install-strip .PHONY: all all-am check check-am clean clean-generic cscopelist-am \ ctags-am distclean distclean-generic distdir dvi dvi-am html \ html-am info info-am install install-am install-data \ install-data-am install-dvi install-dvi-am install-exec \ install-exec-am install-html install-html-am install-info \ install-info-am install-man install-man1 install-pdf \ install-pdf-am install-ps install-ps-am install-strip \ installcheck installcheck-am installdirs maintainer-clean \ maintainer-clean-generic mostlyclean mostlyclean-generic pdf \ pdf-am ps ps-am tags-am uninstall uninstall-am uninstall-man \ uninstall-man1 .PRECIOUS: Makefile #if BUILD_SPECIFICATIONS #BUILT_SOURCES += $(SPECIFICATIONS) #MOSTLYCLEANFILES += $(SPECIFICATIONS) #endif #RFC2629_XSL = $(srcdir)/xml2rfc/rfc2629-noinc.xsl #RFC2629_DTD = $(srcdir)/xml2rfc/rfc2629.dtd #%.txt: %.full $(RFC2629_DTD) # no -d $(RFC2629_DTD) -c $(builddir) $< $@ # #%.full: %.xml $(RFC2629_XSL) # no --nonet $(RFC2629_XSL) $< > $@ # Prevent make from deleting intermediate files #all-full: $(SPECIFICATIONS:.txt=.full) #clean-local: # rm -f $(SPECIFICATIONS:.txt=.full) #.PHONY: all-full # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: memcached-1.6.20/doc/CONTRIBUTORS0000664000175000017500000000303714204760331013061 00000000000000MEMCACHED CONTRIBUTORS This file contains a list of people who have contributed code and effort to the memcached project. If you don't see your name mentioned send email to the memcached mailing list so you can be immortalized. Also see the ChangeLog for even more people who have helped over the years by submitting fixes, patches and reporting bugs. A list is generated from git here: https://memcached.org/about Major authors: -------------- Brad Fitzpatrick -- maintainer, original implementations Anatoly Vorobey -- lots of the modern server code Steven Grimm -- iov writing (less CPU), UDP mode, non-2.0 slab mantissas, multithread, ... Other Contributors ------------------ Evan Martin Nathan Neulinger Eric Hodel Michael Johnson Paul Querna Jamie McCarthy Philip Neustrom Andrew O'Brien Josh Rotenberg Robin H. Johnson Tim Yardley Paolo Borelli Eli Bingham Jean-Francois Bustarret Paul G Paul Lindner Dormando Dustin Sallings Chris Goffinet Tomash Brechko Brian Aker Trond Norbye memcached-1.6.20/doc/protocol-binary.xml0000664000175000017500000017260213704126374015062 00000000000000 Memcache Binary Protocol Six Apart, Ltd.
548 4th Street San Francisco CA 94107 USA aaron@serendipity.palo-alto.ca.us
Sun Microsystems, INC
Haakon VII g. 7B Trondheim NO-7485 Trondheim Norway trond.norbye@sun.com
Applications memcache memcached cache This memo explains the memcache binary protocol for informational purposes. Memcache is a high performance key-value cache. It is intentionally a dumb cache, optimized for speed only. Applications using memcache do not rely on it for data -- a persistent database with guaranteed reliability is strongly recommended -- but applications can run much faster when cached data is available in memcache.
Memcache is a high performance key-value cache. It is intentionally a dumb cache, optimized for speed only. Applications using memcache should not rely on it for data -- a persistent database with guaranteed reliability is strongly recommended -- but applications can run much faster when cached data is available in memcache. Memcache was originally written to make LiveJournal faster. It now powers all of the fastest web sites that you love.
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in .
General format of a packet: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0/ HEADER / / / / / / / +---------------+---------------+---------------+---------------+ 24/ COMMAND-SPECIFIC EXTRAS (as needed) / +/ (note length in the extras length header field) / +---------------+---------------+---------------+---------------+ m/ Key (as needed) / +/ (note length in key length header field) / +---------------+---------------+---------------+---------------+ n/ Value (as needed) / +/ (note length is total body length header field, minus / +/ sum of the extras and key length body fields) / +---------------+---------------+---------------+---------------+ Total 24 bytes
Request header: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Magic | Opcode | Key length | +---------------+---------------+---------------+---------------+ 4| Extras length | Data type | Reserved | +---------------+---------------+---------------+---------------+ 8| Total body length | +---------------+---------------+---------------+---------------+ 12| Opaque | +---------------+---------------+---------------+---------------+ 16| CAS | | | +---------------+---------------+---------------+---------------+ Total 24 bytes
Response header: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Magic | Opcode | Key Length | +---------------+---------------+---------------+---------------+ 4| Extras length | Data type | Status | +---------------+---------------+---------------+---------------+ 8| Total body length | +---------------+---------------+---------------+---------------+ 12| Opaque | +---------------+---------------+---------------+---------------+ 16| CAS | | | +---------------+---------------+---------------+---------------+ Total 24 bytes
Header fields: Magic number. Command code. Length in bytes of the text key that follows the command extras. Status of the response (non-zero on error). Length in bytes of the command extras. Reserved for future use (Sean is using this soon). Really reserved for future use (up for grabs). Length in bytes of extra + key + value. Will be copied back to you in the response. Data version check.
Request packet for this protocol version Response packet for this protocol version Magic byte / version. For each version of the protocol, we'll use a different request/response value pair. This is useful for protocol analyzers to distinguish the nature of the packet from the direction which it is moving. Note, it is common to run a memcached instance on a host that also runs an application server. Such a host will both send and receive memcache packets. The version should hopefully correspond only to different meanings of the command byte. In an ideal world, we will not change the header format. As reserved bytes are given defined meaning, the protocol version / magic byte values should be incremented. Traffic analysis tools are encouraged to identify memcache packets and provide detailed interpretation if the magic bytes are recognized and otherwise to provide a generic breakdown of the packet. Note, that the key and value positions can always be identified even if the magic byte or command opcode are not recognized.
Possible values of this two-byte field: No error Key not found Key exists Value too large Invalid arguments Item not stored Incr/Decr on non-numeric value. Unknown command Out of memory
Possible values of the one-byte field: Get Set Add Replace Delete Increment Decrement Quit Flush GetQ No-op Version GetK GetKQ Append Prepend Stat SetQ AddQ ReplaceQ DeleteQ IncrementQ DecrementQ QuitQ FlushQ AppendQ PrependQ As a convention all of the commands ending with "Q" for Quiet. A quiet version of a command will omit responses that are considered uninteresting. Whether a given response is interesting is dependent upon the command. See the descriptions of the set commands and set commands for examples of commands that include quiet variants.
Possible values of the one-byte field: Raw bytes
All communication is initiated by a request from the client, and the server will respond to each request with zero or multiple packets for each request. If the status code of a response packet is non-nil, the body of the packet will contain a textual error message. If the status code is nil, the command opcode will define the layout of the body of the message.
The following figure illustrates the packet layout for a packet with an error message.
Packet layout: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x09 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x4e ('N') | 0x6f ('o') | 0x74 ('t') | 0x20 (' ') | +---------------+---------------+---------------+---------------+ 28| 0x66 ('f') | 0x6f ('o') | 0x75 ('u') | 0x6e ('n') | +---------------+---------------+---------------+---------------+ 32| 0x64 ('d') | +---------------+ Total 33 bytes (24 byte header, and 9 bytes value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x00 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0001 Total body (8-11) : 0x00000009 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value (24-32): The textual string "Not found"
Request: MUST NOT have extras. MUST have key. MUST NOT have value. Response (if found): MUST have extras. MAY have key. MAY have value. 4 byte flags
Extra data for the get commands: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Flags | +---------------+---------------+---------------+---------------+ Total 4 bytes
The get command gets a single key. The getq command is both mum on cache miss and quiet, holding its response until a non-quiet command is issued. Getk and getkq differs from get and getq by adding the key into the response packet. You're not guaranteed a response to a getq/getkq cache hit until you send a non-getq/getkq command later, which uncorks the server and bundles up IOs to send to the client in one go. Clients should implement multi-get (still important for reducing network roundtrips!) as n pipelined requests, the first n-1 being getq/getkq, the last being a regular get/getk. That way you're guaranteed to get a response, and you know when the server's done. You can also do the naive thing and send n pipelined get/getks, but then you could potentially get back a lot of "NOT_FOUND" error code packets. Alternatively, you can send 'n' getq/getkqs, followed by a 'noop' command.
To request the data associated with the key "Hello" the following fields must be specified in the packet.
get request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 28| 0x6f ('o') | +---------------+ Total 29 bytes (24 byte header, and 5 bytes key) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x00 Key length (2,3) : 0x0005 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000005 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key (24-29): The textual string: "Hello" Value : None
If the item exist on the server the following packet is returned, otherwise a packet with status code != 0 will be returned (see Introduction)
get/getq response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x04 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x09 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 24| 0xde | 0xad | 0xbe | 0xef | +---------------+---------------+---------------+---------------+ 28| 0x57 ('W') | 0x6f ('o') | 0x72 ('r') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 32| 0x64 ('d') | +---------------+ Total 33 bytes (24 byte header, 4 byte extras and 5 byte value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x00 Key length (2,3) : 0x0000 Extra length (4) : 0x04 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000009 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000001 Extras : Flags (24-27): 0xdeadbeef Key : None Value (28-32): The textual string "World"
getk/getkq response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x04 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x09 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 24| 0xde | 0xad | 0xbe | 0xef | +---------------+---------------+---------------+---------------+ 28| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 32| 0x6f ('o') | 0x57 ('W') | 0x6f ('o') | 0x72 ('r') | +---------------+---------------+---------------+---------------+ 36| 0x6c ('l') | 0x64 ('d') | +---------------+---------------+ Total 38 bytes (24 byte header, 4 byte extras, 5 byte key and 5 byte value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x00 Key length (2,3) : 0x0005 Extra length (4) : 0x04 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x0000000E Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000001 Extras : Flags (24-27): 0xdeadbeef Key (28-32): The textual string: "Hello" Value (33-37): The textual string: "World"
MUST have extras. MUST have key. MUST have value. 4 byte flags 4 byte expiration time
Extra data for set/add/replace: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Flags | +---------------+---------------+---------------+---------------+ 4| Expiration | +---------------+---------------+---------------+---------------+ Total 8 bytes
If the Data Version Check (CAS) is nonzero, the requested operation MUST only succeed if the item exists and has a CAS value identical to the provided value. Add MUST fail if the item already exist. Replace MUST fail if the item doesn't exist. Set should store the data unconditionally if the item exists or not. Quiet mutations only return responses on failure. Success is considered the general case and is suppressed when in quiet mode, but errors should not be allowed to go unnoticed.
The following figure shows an add-command for Key: "Hello" Value: "World" Flags: 0xdeadbeef Expiry: in two hours
Add request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x02 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x08 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x12 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0xde | 0xad | 0xbe | 0xef | +---------------+---------------+---------------+---------------+ 28| 0x00 | 0x00 | 0x1c | 0x20 | +---------------+---------------+---------------+---------------+ 32| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 36| 0x6f ('o') | 0x57 ('W') | 0x6f ('o') | 0x72 ('r') | +---------------+---------------+---------------+---------------+ 40| 0x6c ('l') | 0x64 ('d') | +---------------+---------------+ Total 42 bytes (24 byte header, 8 byte extras, 5 byte key and 5 byte value) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x02 Key length (2,3) : 0x0005 Extra length (4) : 0x08 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000012 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : Flags (24-27): 0xdeadbeef Expiry (28-31): 0x00001c20 Key (32-36): The textual string "Hello" Value (37-41): The textual string "World"
The response-packet contains no extra data, and the result of the operation is signaled through the status code. If the command succeeds, the CAS value for the item is returned in the CAS-field of the packet.
Successful add response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x02 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x02 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000001 Extras : None Key : None Value : None
MUST NOT have extras. MUST have key. MUST NOT have value. Delete the item with the specific key.
The following figure shows a delete message for the item "Hello".
Delete request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x04 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 28| 0x6f ('o') | +---------------+ Total 29 bytes (24 byte header, 5 byte value) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x04 Key length (2,3) : 0x0005 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000005 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : The textual string "Hello" Value : None
The response-packet contains no extra data, and the result of the operation is signaled through the status code.
MUST have extras. MUST have key. MUST NOT have value. 8 byte value to add / subtract 8 byte initial value (unsigned) 4 byte expiration time
Extra data for incr/decr: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Amount to add | | | +---------------+---------------+---------------+---------------+ 8| Initial value | | | +---------------+---------------+---------------+---------------+ 16| Expiration | +---------------+---------------+---------------+---------------+ Total 20 bytes
These commands will either add or remove the specified amount to the requested counter. If the counter does not exist, one of two things may happen: If the expiration value is all one-bits (0xffffffff), the operation will fail with NOT_FOUND. For all other expiration values, the operation will succeed by seeding the value for this key with the provided initial value to expire with the provided expiration time. The flags will be set to zero.
incr/decr response body: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 64-bit unsigned response. | | | +---------------+---------------+---------------+---------------+ Total 8 bytes
The following figure shows an incr-command for Key: "counter" Delta: 0x01 Initial: 0x00 Expiry: in two hours
Increment request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x05 | 0x00 | 0x07 | +---------------+---------------+---------------+---------------+ 4| 0x14 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x1b | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 28| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 32| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 36| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 40| 0x00 | 0x00 | 0x1c | 0x20 | +---------------+---------------+---------------+---------------+ 44| 0x63 ('c') | 0x6f ('o') | 0x75 ('u') | 0x6e ('n') | +---------------+---------------+---------------+---------------+ 48| 0x74 ('t') | 0x65 ('e') | 0x72 ('r') | +---------------+---------------+---------------+ Total 51 bytes (24 byte header, 20 byte extras, 7 byte key) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x05 Key length (2,3) : 0x0007 Extra length (4) : 0x14 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x0000001b Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : delta (24-31): 0x0000000000000001 initial (32-39): 0x0000000000000000 expiration (40-43): 0x00001c20 Key : Textual string "counter" Value : None
If the key doesn't exist, the server will respond with the initial value. If not the incremented value will be returned. Let's assume that the key didn't exist, so the initial value is returned.
Increment response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x05 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x08 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 24| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 28| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 32 bytes (24 byte header, 8 byte value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x05 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000008 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000005 Extras : None Key : None Value : 0x0000000000000000
MUST NOT have extras. MUST NOT have key. MUST NOT have value. Close the connection to the server.
Quit request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x07 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x07 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : None
The response-packet contains no extra data, and the result of the operation is signaled through the status code. The server will then close the connection.
MAY have extras. MUST NOT have key. MUST NOT have value. 4 byte expiration time
Extra data for flush: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Expiration | +---------------+---------------+---------------+---------------+ Total 4 bytes
Flush the items in the cache now or some time in the future as specified by the expiration field. See the documentation of the textual protocol for the full description on how to specify the expiration time.
To flush the cache (delete all items) in two hours, the set the following values in the request
Flush request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x08 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x04 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x04 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x00 | 0x00 | 0x1c | 0x20 | +---------------+---------------+---------------+---------------+ Total 28 bytes (24 byte header, 4 byte body) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x08 Key length (2,3) : 0x0000 Extra length (4) : 0x04 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000004 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : Expiry (24-27): 0x00001c20 Key : None Value : None
The response-packet contains no extra data, and the result of the operation is signaled through the status code.
MUST NOT have extras. MUST NOT have key. MUST NOT have value. Used as a keep alive. Flushes outstanding getq/getkq's.
Noop request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x0a | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x0a Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : None
The response-packet contains no extra data, and the result of the operation is signaled through the status code.
MUST NOT have extras. MUST NOT have key. MUST NOT have value. Request the server version. The server responds with a packet containing the version string in the body with the following format: "x.y.z"
Version request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x0b | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x0b Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None
Version response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x0b | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x31 ('1') | 0x2e ('.') | 0x33 ('3') | 0x2e ('.') | +---------------+---------------+---------------+---------------+ 28| 0x31 ('1') | +---------------+ Total 29 bytes (24 byte header, 5 byte body) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x0b Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000005 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : Textual string "1.3.1"
MUST NOT have extras. MUST have key. MUST have value. These commands will either append or prepend the specified value to the requested key.
The following example appends '!' to the 'Hello' key.
Append request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x0e | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x06 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 28| 0x6f ('o') | 0x21 ('!') | +---------------+---------------+ Total 30 bytes (24 byte header, 5 byte key, 1 byte value) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x0e Key length (2,3) : 0x0005 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000006 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key (24-28): The textual string "Hello" Value (29) : "!"
The response-packet contains no extra data, and the result of the operation is signaled through the status code.
MUST NOT have extras. MAY have key. MUST NOT have value. Request server statistics. Without a key specified the server will respond with a "default" set of statistics information. Each piece of statistical information is returned in its own packet (key contains the name of the statistical item and the body contains the value in ASCII format). The sequence of return packets is terminated with a packet that contains no key and no value.
The following example requests all statistics from the server
Stat request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x10 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x10 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : None
The server will send each value in a separate packet with an "empty" packet (no key / no value) to terminate the sequence. Each of the response packets look like the following example:
Stat response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x10 | 0x00 | 0x03 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x07 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x70 ('p') | 0x69 ('i') | 0x64 ('d') | 0x33 ('3') | +---------------+---------------+---------------+---------------+ 28| 0x30 ('0') | 0x37 ('7') | 0x38 ('8') | +---------------+---------------+---------------+ Total 31 bytes (24 byte header, 3 byte key, 4 byte body) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x10 Key length (2,3) : 0x0003 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000007 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : The textual string "pid" Value : The textual string "3078"
Memcache has few authentication and no security layers whatsoever. It is RECOMMENDED that memcache be deployed strictly on closed, protected, back-end networks within a single data center, within a single cluster of servers, or even on a single host, providing shared caching for multiple applications. Memcache MUST NOT be made available on a public network. SASL is supported as an authentication mechanism. See the wiki for more information.
LJ NEEDS MOAR SPEED Danga Interactive http://www.livejournal.com/
Thanks to Brad Fitzpatrick, Anatoly Vorobey, Steven Grimm, and Dustin Sallings, for their work on the memcached server. Thanks to Sean Chittenden, Jonathan Steinert, Brian Aker, Evan Martin, Nathan Neulinger, Eric Hodel, Michael Johnson, Paul Querna, Jamie McCarthy, Philip Neustrom, Andrew O'Brien, Josh Rotenberg, Robin H. Johnson, Tim Yardley, Paolo Borelli, Eli Bingham, Jean-Francois Bustarret, Paul G, Paul Lindner, Alan Kasindorf, Chris Goffinet, Tomash Brechko, and others for their work reporting bugs and maintaining memcached client libraries and bindings in many languages.
memcached-1.6.20/doc/napi_ids.txt0000664000175000017500000000436114301776131013534 00000000000000NAPI ID based worker thread selection -N | --napi_ids= By default memcached assigns connections to worker threads in a round-robin manner. NAPI ID based worker thread selection enables worker threads to be selected based on the NIC HW RX queue on which the incoming request is received. This is enabled using SO_INCOMING_NAPI_ID socket option that is supported in linux kernels 4.12 or higher. This socket option returns a system level unique ID called NAPI ID that is associated with a RX queue on which the last packet associated with that socket is received. This allows memcached to split the incoming flows among threads based on the RX queue on which they are received. Each worker thread is associated with a NIC HW receive queue and services all the connection requests received on a specific RX queue. This mapping between a memcached thread and a HW NIC queue streamlines the flow of data from the NIC to the application. In addition, an optimal path with reduced context switches is possible, if epoll based busy polling (sysctl -w net.core.busy_poll = ) is also enabled. This feature is enabled via a new command line parameter -N or "--napi_ids=", where is the number of available/assigned NIC hardware RX queues through which requests associated with a connection are received. The number of napi_ids specified cannot be greater than the number of worker threads specified using -t/--threads option. If the option is not specified, or the conditions not met, the code defaults to round robin thread selection. During a normal run, each worker thread gets associated with a napi_id and this will establish a 1:1 mapping between the thread and queues. If a new napi_id is received after each thread is associated with its own napi_id (this can happen if num_napi_ids argument doesn't exactly match with the number of RX queues OR if the NIC driver goes through a reload), a stats error counter called 'unexpected_napi_ids' is incremented and all the napi_id's associated with the threads are reset. If -N option is used, but the connection requests are received from a virtual interface like loopback, napi_id returned can be 0. This condition is tracked via a stats counter called 'round_robin_fallback'. memcached-1.6.20/doc/tls.txt0000664000175000017500000001766014340006077012554 00000000000000Securing Memcached with TLS Requirements ------------ We are required to encrypt Memcached network traffic as we deploy our servers in public cloud environments. We decided to implement SSL/TLS for TCP at the network layer of Memcached using OpenSSL libraries. This provides following benefits with the expense of added latency and reduced throughput (to be quantified). # Encryption :Data is encrypted on the wire between Memcached client and server. # Authentication : Optionally, both server and client authenticate each other. # Integrity: Data is not tampered or altered when transmitted between client and server Following are a few additional features. # Certificate refresh: when the server gets a new certificate, new connections will use new certificates without a need of re-starting the server process. # Multiple ports with and without TLS : by default all TCP ports are secured. Optionally we can setup the server to secure a specific TCP port. # Kernel TLS offload (kTLS): when compiled with OpenSSL 3.0.0+ with the `enable-ktls` build-time option set, and running on Linux with kernel version 4.17+ with `CONFIG_TLS` enabled, memcached can transparently offload cryptography operations to the kernel. Depending on a variety of factors (including the workload, NIC support for HW-accelerated cryptography, ciphers in use, etc.), kTLS may offer improved throughput and/or reduced memcached resource consumption. Note that initial implementation does not support session renegotiation. Design ------ We experimented two options for implementing TLS, with SSL buffered events and directly using OpenSSL API. Bufferevents can use the OpenSSL library to implement SSL/TLS. Our experiment used a socket-based bufferevent that tells OpenSSL to communicate with the network directly over. Unlike a worker thread sets callback on the socket, this uses a “bufferevent†object for callbacks. Memcached still has to setup the SSL Context but SSL handshake and object management is done via the “bufferevent_†API. While this was fairly easy to implement, we noticed a higher memory usage as we don’t have much control over allocating evbuffer objects in bufferevents. More over there is a discussion on removing the libevent dependency from Memcached; hence this option was not chosen. OpenSSL library provides APIs for us to directly read/write from a socket. With this option, we create an SSL Context and many SSL objects. The SSL Context object, created at the process level, holds certificates, a private key, and options regarding the TLS protocol and algorithms. SSL objects, created at the connection level, represents SSL sessions. SSL objects are responsible for encryption, and session handshake among other things. There are two ways to do network IO over TLS, either only use SSL_read/SSL_write with a network socket or use the API along with an output/input buffer pair. These buffers are referred as BIO (Basic Input Output) buffers. We started with the first option, create SSL objects with the socket and only interact with SSL_read/SSL_write. +------+ +-----+ |......|--> read(fd) --> BIO_write(rbio) -->|.....|--> SSL_read(ssl) --> IN |......| |.....| |.sock.| |.SSL.| |......| |.....| |......|<-- write(fd) <-- BIO_read(wbio) <--|.....|<-- SSL_write(ssl) <-- OUT +------+ +-----+ | | | | |<-------------------------------->| |<------------------->| | encrypted bytes | | unencrypted bytes | Figure 1 : Network sockets, BIO buffers and SSL_read/SSL_write (reference: https://gist.github.com/darrenjs/4645f115d10aa4b5cebf57483ec82eca) Memcached uses non blocking sockets and implements a rather complex state machine for network IO. A listener thread does the TCP handshake and initiates the SSL handshake after creating an SSL object based on the SSL Context object of the server. If there are no fatal errors, the listener thread hands over the socket to a worker thread. A worker completes the SSL handshake. ----------- ---------------------- | | Client | | Memcached Server | | | |--------------------- | | Listener thread | | TCP connect | | |---------------------> | (accept) | | ClientHello | | |---------------------> | (SSL_accept) | | | | | ServerHello and | | | Certificate, | | | ServerHelloDone | | | <---------------------| | | |--------------------- | | | | | V | |------------------- | | Worker thread | | ClientKeyExchange, | | | ChangeCipherSpec, | | | Finished | | |---------------------> | (SSL_read) | | | | | | | | NewSessionTicket, | | | ChangeCipherSpec, | | | Finished | | | <---------------------| | | | | | Memcached request/ | | | response | | | <-------------------> | (SSL_read/ | | | SSL_write) | ----------- ------------------------- Figure 2 : The initial SSL handshake Setting-up callbacks when the socket is ready for reading/writing is the same for both TLS and non-TLS connections. When the socket is ready, the state machine kicks off and issues a SSL_read/ SSL_write. Note that we implement a SSL_sendmsg wrapper on top of SSL_write to simulate the sendmsg API. This way we don't explicitly use BIO buffers or do BIO_write/BIO_read, but let OpenSSL library to do it on our behalf. Existing state machine takes care of reading the correct amount of bytes and do the error handling when needed. As a best practice, server certificates and keys are periodically refreshed by the PKI. When this happens we want server to use the new certificate without restarting the process. Memcached is a cache and restarting servers affects the latency of applications. We implement the automatic certificate refresh through a command. Upon receiving the "refresh_certs" command, the server reloads the certificates and key to the SSL Context object. Existing connection won't be interrupted but new connections will use the new certificate. We understand not all users want to use TLS or have the OpenSSL dependency. Therefore it's an optional module at the compile time. We can build a TLS capable Memcached server with "./configure --enable-tls". Once the server is built with TLS support, we can enabled it with "-Z" flag or "--enable-ssl". Certificate (-o ssl_chain_cert) and (-o ssl_key) are required parameters while others are optional. Supported options can be listed through "memcached -h". Developers need to have libio-socket-ssl-perl installed for running unit tests. When the server is built with TLS support, we can use "test_tls" make target to run all existing tests over TLS and some additional TLS specific tests. The minimum required OpenSSL version is 1.1.0g. memcached-1.6.20/doc/new_lru.txt0000664000175000017500000000464513704126374013432 00000000000000In versions new enough to have the `-o lru_maintainer` option, a new LRU mechanic is available. Previously: Each slab class has an independent doubly-linked list comprising its LRU. Items are pulled from the bottom and either reclaimed or evicted as needed. Now, enabling `-o lru_maintainer` changes all of the behavior below: * LRU's are now split between HOT, WARM, and COLD LRU's. New items enter the HOT LRU. * Items hit at least twice are considered active. * LRU updates only happen as items reach the bottom of an LRU. If active in HOT, move to WARM, if active in WARM, stay in WARM. If active in COLD, move to WARM. The exception is that items active in COLD are immediately moved to WARM. * HOT/WARM each capped at N% of memory available for that slab class. COLD is uncapped (by default, as of this writing). * HOT/WARM are also age capped by ratios of COLD's age. IE: HOT is capped at N% of memory, or 10% of the age of COLD, whichever comes first. * Items flow from HOT/WARM into COLD. * A background thread exists which shuffles items between/within the LRU's as limits are reached. This includes moves from COLD to WARM. * The background thread can also control the lru_crawler, if enabled. The primary goal is to better protect active items from "scanning". Items which are never hit again will flow from HOT, through COLD, and out the bottom. Items occasionally active (reaching COLD, but being hit before eviction), move to WARM. There they can stay relatively protected. A secondary goal is to improve latency. The LRU locks are no longer used on most item reads, largely during sets and from the background thread. Also the background thread is likely to find expired items and release them back to the slab class asynchronously, which speeds up new allocations. It is recommended to use this feature with the lru crawler as well: `memcached -o lru_maintainer,lru_crawler` - Then it will automatically scan slab classes for items with expired TTL's. If your items are always set to never expire, you can omit this option safely. An extra option: `-o temporary_ttl=N` (when used with lru_maintainer) will make items with a TTL less than or equal to this value use a fourth TEMP LRU. Items stored in TEMP are never bumped within its LRU or moved to other LRU's. They also cannot be evicted. This can help reduce holes and load on the LRU crawler. Do not set temporary_ttl too high or memory could become exhausted. memcached-1.6.20/doc/protocol-binary.txt0000664000175000017500000017211614340006077015073 00000000000000 Network Working Group Stone, Ed. Internet-Draft Six Apart, Ltd. Intended status: Informational Norbye, Ed. Expires: March 1, 2009 Sun Microsystems, INC August 28, 2008 Memcache Binary Protocol draft-stone-memcache-binary-01 Abstract This memo explains the memcache binary protocol for informational purposes. Memcache is a high performance key-value cache. It is intentionally a dumb cache, optimized for speed only. Applications using memcache do not rely on it for data -- a persistent database with guaranteed reliability is strongly recommended -- but applications can run much faster when cached data is available in memcache. Status of This Memo This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79. Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet- Drafts is at http://datatracker.ietf.org/drafts/current/. Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress." This Internet-Draft will expire on March 1, 2009. Copyright Notice Copyright (c) 2008 IETF Trust and the persons identified as the document authors. All rights reserved. This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect Stone & Norbye Expires March 1, 2009 [Page 1] Internet-Draft Memcache Binary Protocol August 2008 to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License. Table of Contents 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 2 1.1. Conventions Used In This Document . . . . . . . . . . . . 3 2. Packet Structure . . . . . . . . . . . . . . . . . . . . . . 3 3. Defined Values . . . . . . . . . . . . . . . . . . . . . . . 5 3.1. Magic Byte . . . . . . . . . . . . . . . . . . . . . . . 5 3.2. Response Status . . . . . . . . . . . . . . . . . . . . . 5 3.3. Command Opcodes . . . . . . . . . . . . . . . . . . . . . 6 3.4. Data Types . . . . . . . . . . . . . . . . . . . . . . . 6 4. Commands . . . . . . . . . . . . . . . . . . . . . . . . . . 7 4.1. Introduction . . . . . . . . . . . . . . . . . . . . . . 7 4.1.1. Example . . . . . . . . . . . . . . . . . . . . . . . 7 4.2. Get, Get Quietly, Get Key, Get Key Quietly . . . . . . . 8 4.2.1. Example . . . . . . . . . . . . . . . . . . . . . . . 9 4.3. Set, Add, Replace . . . . . . . . . . . . . . . . . . . . 13 4.3.1. Example . . . . . . . . . . . . . . . . . . . . . . . 13 4.4. Delete . . . . . . . . . . . . . . . . . . . . . . . . . 15 4.4.1. Example . . . . . . . . . . . . . . . . . . . . . . . 16 4.5. Increment, Decrement . . . . . . . . . . . . . . . . . . 17 4.5.1. Example . . . . . . . . . . . . . . . . . . . . . . . 18 4.6. quit . . . . . . . . . . . . . . . . . . . . . . . . . . 20 4.6.1. Example . . . . . . . . . . . . . . . . . . . . . . . 21 4.7. Flush . . . . . . . . . . . . . . . . . . . . . . . . . . 21 4.7.1. Example . . . . . . . . . . . . . . . . . . . . . . . 22 4.8. noop . . . . . . . . . . . . . . . . . . . . . . . . . . 23 4.8.1. Example . . . . . . . . . . . . . . . . . . . . . . . 24 4.9. version . . . . . . . . . . . . . . . . . . . . . . . . . 24 4.9.1. Example . . . . . . . . . . . . . . . . . . . . . . . 25 4.10. Append, Prepend . . . . . . . . . . . . . . . . . . . . . 26 4.10.1. Example . . . . . . . . . . . . . . . . . . . . . . 27 4.11. Stat . . . . . . . . . . . . . . . . . . . . . . . . . . 28 4.11.1. Example . . . . . . . . . . . . . . . . . . . . . . 28 5. Security Considerations . . . . . . . . . . . . . . . . . . . 30 6. Normative References . . . . . . . . . . . . . . . . . . . . 31 Appendix A. Acknowledgments . . . . . . . . . . . . . . . . . . 31 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 31 1. Introduction Memcache is a high performance key-value cache. It is intentionally a dumb cache, optimized for speed only. Applications using memcache should not rely on it for data -- a persistent database with Stone & Norbye Expires March 1, 2009 [Page 2] Internet-Draft Memcache Binary Protocol August 2008 guaranteed reliability is strongly recommended -- but applications can run much faster when cached data is available in memcache. Memcache was originally written to make LiveJournal [LJ] faster. It now powers all of the fastest web sites that you love. 1.1. Conventions Used In This Document The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [KEYWORDS]. 2. Packet Structure General format of a packet: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0/ HEADER / / / / / / / +---------------+---------------+---------------+---------------+ 24/ COMMAND-SPECIFIC EXTRAS (as needed) / +/ (note length in the extras length header field) / +---------------+---------------+---------------+---------------+ m/ Key (as needed) / +/ (note length in key length header field) / +---------------+---------------+---------------+---------------+ n/ Value (as needed) / +/ (note length is total body length header field, minus / +/ sum of the extras and key length body fields) / +---------------+---------------+---------------+---------------+ Total 24 bytes Stone & Norbye Expires March 1, 2009 [Page 3] Internet-Draft Memcache Binary Protocol August 2008 Request header: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Magic | Opcode | Key length | +---------------+---------------+---------------+---------------+ 4| Extras length | Data type | Reserved | +---------------+---------------+---------------+---------------+ 8| Total body length | +---------------+---------------+---------------+---------------+ 12| Opaque | +---------------+---------------+---------------+---------------+ 16| CAS | | | +---------------+---------------+---------------+---------------+ Total 24 bytes Response header: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Magic | Opcode | Key Length | +---------------+---------------+---------------+---------------+ 4| Extras length | Data type | Status | +---------------+---------------+---------------+---------------+ 8| Total body length | +---------------+---------------+---------------+---------------+ 12| Opaque | +---------------+---------------+---------------+---------------+ 16| CAS | | | +---------------+---------------+---------------+---------------+ Total 24 bytes Header fields: Magic Magic number. Opcode Command code. Key length Length in bytes of the text key that follows the command extras. Status Status of the response (non-zero on error). Extras length Length in bytes of the command extras. Data type Reserved for future use (Sean is using this soon). Stone & Norbye Expires March 1, 2009 [Page 4] Internet-Draft Memcache Binary Protocol August 2008 Reserved Really reserved for future use (up for grabs). Total body length Length in bytes of extra + key + value. Opaque Will be copied back to you in the response. CAS Data version check. 3. Defined Values 3.1. Magic Byte 0x80 Request packet for this protocol version 0x81 Response packet for this protocol version Magic byte / version. For each version of the protocol, we'll use a different request/response value pair. This is useful for protocol analyzers to distinguish the nature of the packet from the direction which it is moving. Note, it is common to run a memcached instance on a host that also runs an application server. Such a host will both send and receive memcache packets. The version should hopefully correspond only to different meanings of the command byte. In an ideal world, we will not change the header format. As reserved bytes are given defined meaning, the protocol version / magic byte values should be incremented. Traffic analysis tools are encouraged to identify memcache packets and provide detailed interpretation if the magic bytes are recognized and otherwise to provide a generic breakdown of the packet. Note, that the key and value positions can always be identified even if the magic byte or command opcode are not recognized. 3.2. Response Status Possible values of this two-byte field: 0x0000 No error 0x0001 Key not found 0x0002 Key exists 0x0003 Value too large 0x0004 Invalid arguments 0x0005 Item not stored 0x0006 Incr/Decr on non-numeric value. 0x0081 Unknown command 0x0082 Out of memory Stone & Norbye Expires March 1, 2009 [Page 5] Internet-Draft Memcache Binary Protocol August 2008 3.3. Command Opcodes Possible values of the one-byte field: 0x00 Get 0x01 Set 0x02 Add 0x03 Replace 0x04 Delete 0x05 Increment 0x06 Decrement 0x07 Quit 0x08 Flush 0x09 GetQ 0x0A No-op 0x0B Version 0x0C GetK 0x0D GetKQ 0x0E Append 0x0F Prepend 0x10 Stat 0x11 SetQ 0x12 AddQ 0x13 ReplaceQ 0x14 DeleteQ 0x15 IncrementQ 0x16 DecrementQ 0x17 QuitQ 0x18 FlushQ 0x19 AppendQ 0x1A PrependQ As a convention all of the commands ending with "Q" for Quiet. A quiet version of a command will omit responses that are considered uninteresting. Whether a given response is interesting is dependent upon the command. See the descriptions of the set commands (Section 4.2) and set commands (Section 4.3) for examples of commands that include quiet variants. 3.4. Data Types Possible values of the one-byte field: 0x00 Raw bytes Stone & Norbye Expires March 1, 2009 [Page 6] Internet-Draft Memcache Binary Protocol August 2008 4. Commands 4.1. Introduction All communication is initiated by a request from the client, and the server will respond to each request with zero or multiple packets for each request. If the status code of a response packet is non-nil, the body of the packet will contain a textual error message. If the status code is nil, the command opcode will define the layout of the body of the message. 4.1.1. Example The following figure illustrates the packet layout for a packet with an error message. Stone & Norbye Expires March 1, 2009 [Page 7] Internet-Draft Memcache Binary Protocol August 2008 Packet layout: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x09 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x4e ('N') | 0x6f ('o') | 0x74 ('t') | 0x20 (' ') | +---------------+---------------+---------------+---------------+ 28| 0x66 ('f') | 0x6f ('o') | 0x75 ('u') | 0x6e ('n') | +---------------+---------------+---------------+---------------+ 32| 0x64 ('d') | +---------------+ Total 33 bytes (24 byte header, and 9 bytes value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x00 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0001 Total body (8-11) : 0x00000009 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value (24-32): The textual string "Not found" 4.2. Get, Get Quietly, Get Key, Get Key Quietly Request: MUST NOT have extras. MUST have key. MUST NOT have value. Stone & Norbye Expires March 1, 2009 [Page 8] Internet-Draft Memcache Binary Protocol August 2008 Response (if found): MUST have extras. MAY have key. MAY have value. o 4 byte flags Extra data for the get commands: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Flags | +---------------+---------------+---------------+---------------+ Total 4 bytes The get command gets a single key. The getq command is both mum on cache miss and quiet, holding its response until a non-quiet command is issued. Getk and getkq differs from get and getq by adding the key into the response packet. You're not guaranteed a response to a getq/getkq cache hit until you send a non-getq/getkq command later, which uncorks the server and bundles up IOs to send to the client in one go. Clients should implement multi-get (still important for reducing network roundtrips!) as n pipelined requests, the first n-1 being getq/getkq, the last being a regular get/getk. That way you're guaranteed to get a response, and you know when the server's done. You can also do the naive thing and send n pipelined get/getks, but then you could potentially get back a lot of "NOT_FOUND" error code packets. Alternatively, you can send 'n' getq/getkqs, followed by a 'noop' command. 4.2.1. Example To request the data associated with the key "Hello" the following fields must be specified in the packet. Stone & Norbye Expires March 1, 2009 [Page 9] Internet-Draft Memcache Binary Protocol August 2008 get request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 28| 0x6f ('o') | +---------------+ Total 29 bytes (24 byte header, and 5 bytes key) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x00 Key length (2,3) : 0x0005 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000005 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key (24-29): The textual string: "Hello" Value : None If the item exist on the server the following packet is returned, otherwise a packet with status code != 0 will be returned (see Introduction (Section 4.1)) Stone & Norbye Expires March 1, 2009 [Page 10] Internet-Draft Memcache Binary Protocol August 2008 get/getq response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x04 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x09 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 24| 0xde | 0xad | 0xbe | 0xef | +---------------+---------------+---------------+---------------+ 28| 0x57 ('W') | 0x6f ('o') | 0x72 ('r') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 32| 0x64 ('d') | +---------------+ Total 33 bytes (24 byte header, 4 byte extras and 5 byte value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x00 Key length (2,3) : 0x0000 Extra length (4) : 0x04 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000009 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000001 Extras : Flags (24-27): 0xdeadbeef Key : None Value (28-32): The textual string "World" Stone & Norbye Expires March 1, 2009 [Page 11] Internet-Draft Memcache Binary Protocol August 2008 getk/getkq response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x04 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x09 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 24| 0xde | 0xad | 0xbe | 0xef | +---------------+---------------+---------------+---------------+ 28| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 32| 0x6f ('o') | 0x57 ('W') | 0x6f ('o') | 0x72 ('r') | +---------------+---------------+---------------+---------------+ 36| 0x6c ('l') | 0x64 ('d') | +---------------+---------------+ Total 38 bytes (24 byte header, 4 byte extras, 5 byte key and 5 byte value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x00 Key length (2,3) : 0x0005 Extra length (4) : 0x04 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x0000000E Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000001 Extras : Flags (24-27): 0xdeadbeef Key (28-32): The textual string: "Hello" Value (33-37): The textual string: "World" Stone & Norbye Expires March 1, 2009 [Page 12] Internet-Draft Memcache Binary Protocol August 2008 4.3. Set, Add, Replace MUST have extras. MUST have key. MUST have value. o 4 byte flags o 4 byte expiration time Extra data for set/add/replace: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Flags | +---------------+---------------+---------------+---------------+ 4| Expiration | +---------------+---------------+---------------+---------------+ Total 8 bytes If the Data Version Check (CAS) is nonzero, the requested operation MUST only succeed if the item exists and has a CAS value identical to the provided value. Add MUST fail if the item already exist. Replace MUST fail if the item doesn't exist. Set should store the data unconditionally if the item exists or not. Quiet mutations only return responses on failure. Success is considered the general case and is suppressed when in quiet mode, but errors should not be allowed to go unnoticed. 4.3.1. Example The following figure shows an add-command for Key: "Hello" Value: "World" Flags: 0xdeadbeef Expiry: in two hours Stone & Norbye Expires March 1, 2009 [Page 13] Internet-Draft Memcache Binary Protocol August 2008 Add request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x02 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x08 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x12 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0xde | 0xad | 0xbe | 0xef | +---------------+---------------+---------------+---------------+ 28| 0x00 | 0x00 | 0x1c | 0x20 | +---------------+---------------+---------------+---------------+ 32| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 36| 0x6f ('o') | 0x57 ('W') | 0x6f ('o') | 0x72 ('r') | +---------------+---------------+---------------+---------------+ 40| 0x6c ('l') | 0x64 ('d') | +---------------+---------------+ Total 42 bytes (24 byte header, 8 byte extras, 5 byte key and 5 byte value) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x02 Key length (2,3) : 0x0005 Extra length (4) : 0x08 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000012 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : Flags (24-27): 0xdeadbeef Expiry (28-31): 0x00001c20 Key (32-36): The textual string "Hello" Value (37-41): The textual string "World" Stone & Norbye Expires March 1, 2009 [Page 14] Internet-Draft Memcache Binary Protocol August 2008 The response-packet contains no extra data, and the result of the operation is signaled through the status code. If the command succeeds, the CAS value for the item is returned in the CAS-field of the packet. Successful add response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x02 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x02 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000001 Extras : None Key : None Value : None 4.4. Delete MUST NOT have extras. MUST have key. MUST NOT have value. Delete the item with the specific key. Stone & Norbye Expires March 1, 2009 [Page 15] Internet-Draft Memcache Binary Protocol August 2008 4.4.1. Example The following figure shows a delete message for the item "Hello". Delete request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x04 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 28| 0x6f ('o') | +---------------+ Total 29 bytes (24 byte header, 5 byte value) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x04 Key length (2,3) : 0x0005 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000005 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : The textual string "Hello" Value : None The response-packet contains no extra data, and the result of the operation is signaled through the status code. Stone & Norbye Expires March 1, 2009 [Page 16] Internet-Draft Memcache Binary Protocol August 2008 4.5. Increment, Decrement MUST have extras. MUST have key. MUST NOT have value. o 8 byte value to add / subtract o 8 byte initial value (unsigned) o 4 byte expiration time Extra data for incr/decr: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Amount to add | | | +---------------+---------------+---------------+---------------+ 8| Initial value | | | +---------------+---------------+---------------+---------------+ 16| Expiration | +---------------+---------------+---------------+---------------+ Total 20 bytes These commands will either add or remove the specified amount to the requested counter. If the counter does not exist, one of two things may happen: 1. If the expiration value is all one-bits (0xffffffff), the operation will fail with NOT_FOUND. 2. For all other expiration values, the operation will succeed by seeding the value for this key with the provided initial value to expire with the provided expiration time. The flags will be set to zero. incr/decr response body: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 64-bit unsigned response. | | | +---------------+---------------+---------------+---------------+ Total 8 bytes Stone & Norbye Expires March 1, 2009 [Page 17] Internet-Draft Memcache Binary Protocol August 2008 4.5.1. Example The following figure shows an incr-command for Key: "counter" Delta: 0x01 Initial: 0x00 Expiry: in two hours Increment request: Stone & Norbye Expires March 1, 2009 [Page 18] Internet-Draft Memcache Binary Protocol August 2008 Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x05 | 0x00 | 0x07 | +---------------+---------------+---------------+---------------+ 4| 0x14 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x1b | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 28| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 32| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 36| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 40| 0x00 | 0x00 | 0x1c | 0x20 | +---------------+---------------+---------------+---------------+ 44| 0x63 ('c') | 0x6f ('o') | 0x75 ('u') | 0x6e ('n') | +---------------+---------------+---------------+---------------+ 48| 0x74 ('t') | 0x65 ('e') | 0x72 ('r') | +---------------+---------------+---------------+ Total 51 bytes (24 byte header, 20 byte extras, 7 byte key) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x05 Key length (2,3) : 0x0007 Extra length (4) : 0x14 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x0000001b Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : delta (24-31): 0x0000000000000001 initial (32-39): 0x0000000000000000 expiration (40-43): 0x00001c20 Key : Textual string "counter" Value : None Stone & Norbye Expires March 1, 2009 [Page 19] Internet-Draft Memcache Binary Protocol August 2008 If the key doesn't exist, the server will respond with the initial value. If not the incremented value will be returned. Let's assume that the key didn't exist, so the initial value is returned. Increment response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x05 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x08 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 24| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 28| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 32 bytes (24 byte header, 8 byte value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x05 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000008 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000005 Extras : None Key : None Value : 0x0000000000000000 4.6. quit MUST NOT have extras. MUST NOT have key. MUST NOT have value. Stone & Norbye Expires March 1, 2009 [Page 20] Internet-Draft Memcache Binary Protocol August 2008 Close the connection to the server. 4.6.1. Example Quit request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x07 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x07 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : None The response-packet contains no extra data, and the result of the operation is signaled through the status code. The server will then close the connection. 4.7. Flush MAY have extras. MUST NOT have key. MUST NOT have value. Stone & Norbye Expires March 1, 2009 [Page 21] Internet-Draft Memcache Binary Protocol August 2008 o 4 byte expiration time Extra data for flush: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Expiration | +---------------+---------------+---------------+---------------+ Total 4 bytes Flush the items in the cache now or some time in the future as specified by the expiration field. See the documentation of the textual protocol for the full description on how to specify the expiration time. 4.7.1. Example To flush the cache (delete all items) in two hours, the set the following values in the request Stone & Norbye Expires March 1, 2009 [Page 22] Internet-Draft Memcache Binary Protocol August 2008 Flush request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x08 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x04 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x04 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x00 | 0x00 | 0x1c | 0x20 | +---------------+---------------+---------------+---------------+ Total 28 bytes (24 byte header, 4 byte body) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x08 Key length (2,3) : 0x0000 Extra length (4) : 0x04 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000004 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : Expiry (24-27): 0x00001c20 Key : None Value : None The response-packet contains no extra data, and the result of the operation is signaled through the status code. 4.8. noop MUST NOT have extras. MUST NOT have key. MUST NOT have value. Used as a keep alive. Flushes outstanding getq/getkq's. Stone & Norbye Expires March 1, 2009 [Page 23] Internet-Draft Memcache Binary Protocol August 2008 4.8.1. Example Noop request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x0a | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x0a Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : None The response-packet contains no extra data, and the result of the operation is signaled through the status code. 4.9. version MUST NOT have extras. MUST NOT have key. MUST NOT have value. Request the server version. Stone & Norbye Expires March 1, 2009 [Page 24] Internet-Draft Memcache Binary Protocol August 2008 The server responds with a packet containing the version string in the body with the following format: "x.y.z" 4.9.1. Example Version request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x0b | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x0b Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Stone & Norbye Expires March 1, 2009 [Page 25] Internet-Draft Memcache Binary Protocol August 2008 Version response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x0b | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x31 ('1') | 0x2e ('.') | 0x33 ('3') | 0x2e ('.') | +---------------+---------------+---------------+---------------+ 28| 0x31 ('1') | +---------------+ Total 29 bytes (24 byte header, 5 byte body) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x0b Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000005 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : Textual string "1.3.1" 4.10. Append, Prepend MUST NOT have extras. MUST have key. MUST have value. These commands will either append or prepend the specified value to the requested key. Stone & Norbye Expires March 1, 2009 [Page 26] Internet-Draft Memcache Binary Protocol August 2008 4.10.1. Example The following example appends '!' to the 'Hello' key. Append request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x0e | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x06 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 28| 0x6f ('o') | 0x21 ('!') | +---------------+---------------+ Total 30 bytes (24 byte header, 5 byte key, 1 byte value) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x0e Key length (2,3) : 0x0005 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000006 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key (24-28): The textual string "Hello" Value (29) : "!" The response-packet contains no extra data, and the result of the operation is signaled through the status code. Stone & Norbye Expires March 1, 2009 [Page 27] Internet-Draft Memcache Binary Protocol August 2008 4.11. Stat MUST NOT have extras. MAY have key. MUST NOT have value. Request server statistics. Without a key specified the server will respond with a "default" set of statistics information. Each piece of statistical information is returned in its own packet (key contains the name of the statistical item and the body contains the value in ASCII format). The sequence of return packets is terminated with a packet that contains no key and no value. 4.11.1. Example The following example requests all statistics from the server Stone & Norbye Expires March 1, 2009 [Page 28] Internet-Draft Memcache Binary Protocol August 2008 Stat request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x10 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x10 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : None The server will send each value in a separate packet with an "empty" packet (no key / no value) to terminate the sequence. Each of the response packets look like the following example: Stone & Norbye Expires March 1, 2009 [Page 29] Internet-Draft Memcache Binary Protocol August 2008 Stat response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x10 | 0x00 | 0x03 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x07 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x70 ('p') | 0x69 ('i') | 0x64 ('d') | 0x33 ('3') | +---------------+---------------+---------------+---------------+ 28| 0x30 ('0') | 0x37 ('7') | 0x38 ('8') | +---------------+---------------+---------------+ Total 31 bytes (24 byte header, 3 byte key, 4 byte body) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x10 Key length (2,3) : 0x0003 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000007 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : The textual string "pid" Value : The textual string "3078" 5. Security Considerations Memcache has few authentication and no security layers whatsoever. It is RECOMMENDED that memcache be deployed strictly on closed, protected, back-end networks within a single data center, within a single cluster of servers, or even on a single host, providing shared caching for multiple applications. Memcache MUST NOT be made available on a public network. Stone & Norbye Expires March 1, 2009 [Page 30] Internet-Draft Memcache Binary Protocol August 2008 SASL is supported as an authentication mechanism. See the wiki for more information. 6. Normative References [KEYWORDS] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997. [LJ] Fitzpatrick, B., "LJ NEEDS MOAR SPEED", 10 1999. Appendix A. Acknowledgments Thanks to Brad Fitzpatrick, Anatoly Vorobey, Steven Grimm, and Dustin Sallings, for their work on the memcached server. Thanks to Sean Chittenden, Jonathan Steinert, Brian Aker, Evan Martin, Nathan Neulinger, Eric Hodel, Michael Johnson, Paul Querna, Jamie McCarthy, Philip Neustrom, Andrew O'Brien, Josh Rotenberg, Robin H. Johnson, Tim Yardley, Paolo Borelli, Eli Bingham, Jean- Francois Bustarret, Paul G, Paul Lindner, Alan Kasindorf, Chris Goffinet, Tomash Brechko, and others for their work reporting bugs and maintaining memcached client libraries and bindings in many languages. Authors' Addresses Aaron Stone (editor) Six Apart, Ltd. 548 4th Street San Francisco, CA 94107 USA Email: aaron@serendipity.palo-alto.ca.us Trond Norbye (editor) Sun Microsystems, INC Haakon VII g. 7B Trondheim NO-7485 Trondheim Norway Email: trond.norbye@sun.com Stone & Norbye Expires March 1, 2009 [Page 31] memcached-1.6.20/doc/Makefile.in0000664000175000017500000003722414427544303013261 00000000000000# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. @SET_MAKE@ VPATH = @srcdir@ am__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) pkgdatadir = $(datadir)/@PACKAGE@ pkgincludedir = $(includedir)/@PACKAGE@ pkglibdir = $(libdir)/@PACKAGE@ pkglibexecdir = $(libexecdir)/@PACKAGE@ am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd install_sh_DATA = $(install_sh) -c -m 644 install_sh_PROGRAM = $(install_sh) -c install_sh_SCRIPT = $(install_sh) -c INSTALL_HEADER = $(INSTALL_DATA) transform = $(program_transform_name) NORMAL_INSTALL = : PRE_INSTALL = : POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : build_triplet = @build@ host_triplet = @host@ subdir = doc ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/version.m4 \ $(top_srcdir)/m4/c99-backport.m4 $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = AM_V_P = $(am__v_P_@AM_V@) am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) am__v_P_0 = false am__v_P_1 = : AM_V_GEN = $(am__v_GEN_@AM_V@) am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) am__v_GEN_0 = @echo " GEN " $@; am__v_GEN_1 = AM_V_at = $(am__v_at_@AM_V@) am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) am__v_at_0 = @ am__v_at_1 = SOURCES = DIST_SOURCES = am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; am__vpath_adj = case $$p in \ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ *) f=$$p;; \ esac; am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; am__install_max = 40 am__nobase_strip_setup = \ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` am__nobase_strip = \ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" am__nobase_list = $(am__nobase_strip_setup); \ for p in $$list; do echo "$$p $$p"; done | \ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ if (++n[$$2] == $(am__install_max)) \ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ END { for (dir in files) print dir, files[dir] }' am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' am__uninstall_files_from_dir = { \ test -z "$$files" \ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ $(am__cd) "$$dir" && rm -f $$files; }; \ } man1dir = $(mandir)/man1 am__installdirs = "$(DESTDIR)$(man1dir)" NROFF = nroff MANS = $(man_MANS) am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) am__DIST_COMMON = $(srcdir)/Makefile.in DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ CC = @CC@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ CYGPATH_W = @CYGPATH_W@ DEFS = @DEFS@ DEPDIR = @DEPDIR@ DTRACE = @DTRACE@ DTRACEFLAGS = @DTRACEFLAGS@ ECHO_C = @ECHO_C@ ECHO_N = @ECHO_N@ ECHO_T = @ECHO_T@ EGREP = @EGREP@ ENABLE_SASL = @ENABLE_SASL@ ETAGS = @ETAGS@ EXEEXT = @EXEEXT@ GREP = @GREP@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ LDFLAGS = @LDFLAGS@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ LTLIBOBJS = @LTLIBOBJS@ MAKEINFO = @MAKEINFO@ MKDIR_P = @MKDIR_P@ OBJEXT = @OBJEXT@ OPENSSL_CFLAGS = @OPENSSL_CFLAGS@ OPENSSL_LIBS = @OPENSSL_LIBS@ PACKAGE = @PACKAGE@ PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ PKG_CONFIG = @PKG_CONFIG@ PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ PROFILER = @PROFILER@ PROFILER_FLAGS = @PROFILER_FLAGS@ PROFILER_LDFLAGS = @PROFILER_LDFLAGS@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ VERSION = @VERSION@ XML2RFC = @XML2RFC@ XSLTPROC = @XSLTPROC@ abs_builddir = @abs_builddir@ abs_srcdir = @abs_srcdir@ abs_top_builddir = @abs_top_builddir@ abs_top_srcdir = @abs_top_srcdir@ ac_ct_CC = @ac_ct_CC@ am__include = @am__include@ am__leading_dot = @am__leading_dot@ am__quote = @am__quote@ am__tar = @am__tar@ am__untar = @am__untar@ bindir = @bindir@ build = @build@ build_alias = @build_alias@ build_cpu = @build_cpu@ build_os = @build_os@ build_vendor = @build_vendor@ builddir = @builddir@ datadir = @datadir@ datarootdir = @datarootdir@ docdir = @docdir@ dvidir = @dvidir@ exec_prefix = @exec_prefix@ host = @host@ host_alias = @host_alias@ host_cpu = @host_cpu@ host_os = @host_os@ host_vendor = @host_vendor@ htmldir = @htmldir@ includedir = @includedir@ infodir = @infodir@ install_sh = @install_sh@ libdir = @libdir@ libexecdir = @libexecdir@ localedir = @localedir@ localstatedir = @localstatedir@ mandir = @mandir@ mkdir_p = @mkdir_p@ oldincludedir = @oldincludedir@ pdfdir = @pdfdir@ prefix = @prefix@ program_transform_name = @program_transform_name@ psdir = @psdir@ runstatedir = @runstatedir@ sbindir = @sbindir@ sharedstatedir = @sharedstatedir@ srcdir = @srcdir@ sysconfdir = @sysconfdir@ target_alias = @target_alias@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ man_MANS = memcached.1 SPECIFICATIONS = protocol-binary.txt protocol-binary-range.txt # When we make dist always include the generated specifications so people don't # have to have xml2rfc and xsltproc installed EXTRA_DIST = $(srcdir)/*.txt $(SPECIFICATIONS) BUILT_SOURCES = MOSTLYCLEANFILES = all: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) all-am .SUFFIXES: $(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ && { if test -f $@; then exit 0; else break; fi; }; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign doc/Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign doc/Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(top_srcdir)/configure: $(am__configure_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(ACLOCAL_M4): $(am__aclocal_m4_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): install-man1: $(man_MANS) @$(NORMAL_INSTALL) @list1=''; \ list2='$(man_MANS)'; \ test -n "$(man1dir)" \ && test -n "`echo $$list1$$list2`" \ || exit 0; \ echo " $(MKDIR_P) '$(DESTDIR)$(man1dir)'"; \ $(MKDIR_P) "$(DESTDIR)$(man1dir)" || exit 1; \ { for i in $$list1; do echo "$$i"; done; \ if test -n "$$list2"; then \ for i in $$list2; do echo "$$i"; done \ | sed -n '/\.1[a-z]*$$/p'; \ fi; \ } | while read p; do \ if test -f $$p; then d=; else d="$(srcdir)/"; fi; \ echo "$$d$$p"; echo "$$p"; \ done | \ sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \ -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \ sed 'N;N;s,\n, ,g' | { \ list=; while read file base inst; do \ if test "$$base" = "$$inst"; then list="$$list $$file"; else \ echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man1dir)/$$inst'"; \ $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man1dir)/$$inst" || exit $$?; \ fi; \ done; \ for i in $$list; do echo "$$i"; done | $(am__base_list) | \ while read files; do \ test -z "$$files" || { \ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man1dir)'"; \ $(INSTALL_DATA) $$files "$(DESTDIR)$(man1dir)" || exit $$?; }; \ done; } uninstall-man1: @$(NORMAL_UNINSTALL) @list=''; test -n "$(man1dir)" || exit 0; \ files=`{ for i in $$list; do echo "$$i"; done; \ l2='$(man_MANS)'; for i in $$l2; do echo "$$i"; done | \ sed -n '/\.1[a-z]*$$/p'; \ } | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \ -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \ dir='$(DESTDIR)$(man1dir)'; $(am__uninstall_files_from_dir) tags TAGS: ctags CTAGS: cscope cscopelist: distdir: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(DISTFILES) @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ list='$(DISTFILES)'; \ dist_files=`for file in $$list; do echo $$file; done | \ sed -e "s|^$$srcdirstrip/||;t" \ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ case $$dist_files in \ */*) $(MKDIR_P) `echo "$$dist_files" | \ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ sort -u` ;; \ esac; \ for file in $$dist_files; do \ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ if test -d $$d/$$file; then \ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ if test -d "$(distdir)/$$file"; then \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ else \ test -f "$(distdir)/$$file" \ || cp -p $$d/$$file "$(distdir)/$$file" \ || exit 1; \ fi; \ done check-am: all-am check: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) check-am all-am: Makefile $(MANS) installdirs: for dir in "$(DESTDIR)$(man1dir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) install-am install-exec: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data: install-data-am uninstall: uninstall-am install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-am install-strip: if test -z '$(STRIP)'; then \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ install; \ else \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ fi mostlyclean-generic: -test -z "$(MOSTLYCLEANFILES)" || rm -f $(MOSTLYCLEANFILES) clean-generic: distclean-generic: -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." -test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES) clean: clean-am clean-am: clean-generic mostlyclean-am distclean: distclean-am -rm -f Makefile distclean-am: clean-am distclean-generic dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-man install-dvi: install-dvi-am install-dvi-am: install-exec-am: install-html: install-html-am install-html-am: install-info: install-info-am install-info-am: install-man: install-man1 install-pdf: install-pdf-am install-pdf-am: install-ps: install-ps-am install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-am -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-am mostlyclean-am: mostlyclean-generic pdf: pdf-am pdf-am: ps: ps-am ps-am: uninstall-am: uninstall-man uninstall-man: uninstall-man1 .MAKE: all check install install-am install-exec install-strip .PHONY: all all-am check check-am clean clean-generic cscopelist-am \ ctags-am distclean distclean-generic distdir dvi dvi-am html \ html-am info info-am install install-am install-data \ install-data-am install-dvi install-dvi-am install-exec \ install-exec-am install-html install-html-am install-info \ install-info-am install-man install-man1 install-pdf \ install-pdf-am install-ps install-ps-am install-strip \ installcheck installcheck-am installdirs maintainer-clean \ maintainer-clean-generic mostlyclean mostlyclean-generic pdf \ pdf-am ps ps-am tags-am uninstall uninstall-am uninstall-man \ uninstall-man1 .PRECIOUS: Makefile #if BUILD_SPECIFICATIONS #BUILT_SOURCES += $(SPECIFICATIONS) #MOSTLYCLEANFILES += $(SPECIFICATIONS) #endif #RFC2629_XSL = $(srcdir)/xml2rfc/rfc2629-noinc.xsl #RFC2629_DTD = $(srcdir)/xml2rfc/rfc2629.dtd #%.txt: %.full $(RFC2629_DTD) # @XML2RFC@ -d $(RFC2629_DTD) -c $(builddir) $< $@ # #%.full: %.xml $(RFC2629_XSL) # @XSLTPROC@ --nonet $(RFC2629_XSL) $< > $@ # Prevent make from deleting intermediate files #all-full: $(SPECIFICATIONS:.txt=.full) #clean-local: # rm -f $(SPECIFICATIONS:.txt=.full) #.PHONY: all-full # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: memcached-1.6.20/doc/memcached.10000664000175000017500000001507614204760331013177 00000000000000.TH MEMCACHED 1 "April 11, 2005" .SH NAME memcached \- high-performance memory object caching system .SH SYNOPSIS .B memcached .RI [ options ] .br .SH DESCRIPTION This manual page documents briefly the .B memcached memory object caching daemon. .PP .B memcached is a flexible memory object caching daemon designed to alleviate database load in dynamic web applications by storing objects in memory. It's based on libevent to scale to any size needed, and is specifically optimized to avoid swapping and always use non-blocking I/O. .br .SH OPTIONS These programs follow the usual GNU command line syntax. A summary of options is included below. .TP .B \-s, --unix-socket= Unix socket path to listen on (disables network support). .TP .B \-A, --enable-shutdown Enable ascii "shutdown" command. .TP .B \-a, --unix-mask= Permissions (in octal format) for Unix socket created with \-s option. .TP .B \-l, --listen= Listen on ; default to INADDR_ANY. may be specified as host:port. If you don't specify a port number, the value you specified with -p or -U is used. You may specify multiple addresses separated by comma or by using -l multiple times. This is an important option to consider as there is no other way to secure the installation. Binding to an internal or firewalled network interface is suggested. .TP .B \-d, --daemon Run memcached as a daemon. .TP .B \-u, --user= Assume the identity of (only when run as root). .TP .B \-m, --memory-limit= Use MB memory max to use for object storage; the default is 64 megabytes. .TP .B \-c, --conn-limit= Use max simultaneous connections; the default is 1024. .TP .B \-R, --max-reqs-per-event= This option seeks to prevent client starvation by setting a limit to the number of sequential requests the server will process from an individual client connection. Once a connection has exceeded this value, the server will attempt to process I/O on other connections before handling any further request from this connection. The default value for this option is 20. .TP .B \-k, --lock-memory Lock down all paged memory. This is a somewhat dangerous option with large caches, so consult the README and memcached homepage for configuration suggestions. .TP .B \-p, --port= Listen on TCP port , the default is port 11211. 0 means off. .TP .B \-U, --udp-port= Listen on UDP port , the default is port 0, which is off. .TP .B \-M, --disable-evictions Disable automatic removal of items from the cache when out of memory. Additions will not be possible until adequate space is freed up. .TP .B \-r, --enable-coredumps Raise the core file size limit to the maximum allowable. .TP .B \-f, --slab-growth-factor= Use as the multiplier for computing the sizes of memory chunks that items are stored in. A lower value may result in less wasted memory depending on the total amount of memory available and the distribution of item sizes. The default is 1.25. .TP .B \-n, --slab-min-size= Allocate a minimum of bytes for the item key, value, and flags. The default is 48. If you have a lot of small keys and values, you can get a significant memory efficiency gain with a lower value. If you use a high chunk growth factor (\-f option), on the other hand, you may want to increase the size to allow a bigger percentage of your items to fit in the most densely packed (smallest) chunks. .TP .B \-C, --disable-cas Disable the use of CAS (and reduce the per-item size by 8 bytes). .TP .B \-h, --help Show the version of memcached and a summary of options. .TP .B \-v, --verbose Be verbose during the event loop; print out errors and warnings. .TP .B \-vv Be even more verbose; same as \-v but also print client commands and responses. .TP .B \-vvv Be extremely verbose; same of the above and also print internal state transitions. .TP .B \-i, --license Print memcached and libevent licenses. .TP .B \-P, --pidfile= Print pidfile to , only used under \-d option. .TP .B \-t, --threads= Number of threads to use to process incoming requests. This option is only meaningful if memcached was compiled with thread support enabled. It is typically not useful to set this higher than the number of CPU cores on the memcached server. Setting a high number (64 or more) of worker threads is not recommended. The default is 4. .TP .B \-D Use as the delimiter between key prefixes and IDs. This is used for per-prefix stats reporting. The default is ":" (colon). If this option is specified, stats collection is turned on automatically; if not, then it may be turned on by sending the "stats detail on" command to the server. .TP .B \-L, --enable-largepages Try to use large memory pages (if available). Increasing the memory page size could reduce the number of TLB misses and improve the performance. In order to get large pages from the OS, memcached will allocate the total item-cache in one large chunk. Only available if supported on your OS. .TP .B \-b, --listen-backlog= Set the backlog queue limit to connections. The default is 1024. .TP .B \-B, --protocol= Specify the binding protocol to use. By default, the server will autonegotiate client connections. By using this option, you can specify the protocol clients must speak. Possible options are "auto" (the default, autonegotiation behavior), "ascii" and "binary". .TP .B \-I, --max-item-size= Override the default size of each slab page. The default size is 1mb. Default value for this parameter is 1m, minimum is 1k, max is 1G (1024 * 1024 * 1024). Adjusting this value changes the item size limit. .TP .B \-S, --enable-sasl Turn on SASL authentication. This option is only meaningful if memcached was compiled with SASL support enabled. .TP .B \-F, --disable-flush-all Disables the "flush_all" command. The cmd_flush counter will increment, but clients will receive an error message and the flush will not occur. .TP .B \-X, --disable-dumping Disables the "stats cachedump" and "lru_crawler metadump" commands. .TP .B \-o, --extended= Comma separated list of extended or experimental options. See \-h or wiki for up to date list. .TP .B \-V, --version print version and exit .br .SH LICENSE The memcached daemon is copyright Danga Interactive and is distributed under the BSD license. Note that daemon clients are licensed separately. .br .SH SEE ALSO The README file that comes with memcached .br .B https://www.memcached.org .SH AUTHOR The memcached daemon was written by Anatoly Vorobey .B and Brad Fitzpatrick .B and the rest of the crew of Danga Interactive .B https://www.danga.com .br memcached-1.6.20/doc/Doxyfile0000664000175000017500000014452113704126374012722 00000000000000# Doxyfile 1.5.2 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project # # All text after a hash (#) is considered a comment and will be ignored # The format is: # TAG = value [value, ...] # For lists items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (" ") #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the config file that # follow. The default is UTF-8 which is also the encoding used for all text before # the first occurrence of this tag. Doxygen uses libiconv (or the iconv built into # libc) for the transcoding. See http://www.gnu.org/software/libiconv for the list of # possible encodings. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded # by quotes) that should identify the project. PROJECT_NAME = memcached # The PROJECT_NUMBER tag can be used to enter a project or revision number. # This could be handy for archiving the generated documentation or # if some version control system is used. PROJECT_NUMBER = 0.8 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) # base path where the generated documentation will be put. # If a relative path is entered, it will be relative to the location # where doxygen was started. If left blank the current directory will be used. OUTPUT_DIRECTORY = doxygen # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create # 4096 sub-directories (in 2 levels) under the output directory of each output # format and will distribute the generated files over these directories. # Enabling this option can be useful when feeding doxygen a huge amount of # source files, where putting all generated files in the same directory would # otherwise cause performance problems for the file system. CREATE_SUBDIRS = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # The default language is English, other supported languages are: # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, # Croatian, Czech, Danish, Dutch, Finnish, French, German, Greek, Hungarian, # Italian, Japanese, Japanese-en (Japanese with English messages), Korean, # Korean-en, Lithuanian, Norwegian, Polish, Portuguese, Romanian, Russian, # Serbian, Slovak, Slovene, Spanish, Swedish, and Ukrainian. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will # include brief member descriptions after the members that are listed in # the file and class documentation (similar to JavaDoc). # Set to NO to disable this. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend # the brief description of a member or function before the detailed description. # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. REPEAT_BRIEF = NO # This tag implements a quasi-intelligent brief description abbreviator # that is used to form the text in various listings. Each string # in this list, if found as the leading text of the brief description, will be # stripped from the text and the result after processing the whole list, is # used as the annotated text. Otherwise, the brief description is used as-is. # If left blank, the following values are used ("$name" is automatically # replaced with the name of the entity): "The $name class" "The $name widget" # "The $name file" "is" "provides" "specifies" "contains" # "represents" "a" "an" "the" ABBREVIATE_BRIEF = # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # Doxygen will generate a detailed section even if there is only a brief # description. ALWAYS_DETAILED_SEC = YES # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full # path before files name in the file list and in the header files. If set # to NO the shortest path that makes the file name unique will be used. FULL_PATH_NAMES = NO # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag # can be used to strip a user-defined part of the path. Stripping is # only done if one of the specified strings matches the left-hand part of # the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the # path to strip. STRIP_FROM_PATH = # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of # the path mentioned in the documentation of a class, which tells # the reader which header file to include in order to use a class. # If left blank only the name of the header file containing the class # definition is used. Otherwise one should specify the include paths that # are normally passed to the compiler using the -I flag. STRIP_FROM_INC_PATH = # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter # (but less readable) file names. This can be useful is your file systems # doesn't support long names like on DOS, Mac, or CD-ROM. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen # will interpret the first line (until the first dot) of a JavaDoc-style # comment as the brief description. If set to NO, the JavaDoc # comments will behave just like the Qt-style comments (thus requiring an # explicit @brief command for a brief description. JAVADOC_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen # treat a multi-line C++ special comment block (i.e. a block of //! or /// # comments) as a brief description. This used to be the default behaviour. # The new default is to treat a multi-line C++ comment block as a detailed # description. Set this tag to YES if you prefer the old behaviour instead. MULTILINE_CPP_IS_BRIEF = NO # If the DETAILS_AT_TOP tag is set to YES then Doxygen # will output the detailed description near the top, like JavaDoc. # If set to NO, the detailed description appears after the member # documentation. DETAILS_AT_TOP = NO # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented # member inherits the documentation from any documented member that it # re-implements. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce # a new page for each member. If set to NO, the documentation of a member will # be part of the file/class/namespace that contains it. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. # Doxygen uses this value to replace tabs by spaces in code fragments. TAB_SIZE = 8 # This tag can be used to specify a number of aliases that acts # as commands in the documentation. An alias has the form "name=value". # For example adding "sideeffect=\par Side Effects:\n" will allow you to # put the command \sideeffect (or @sideeffect) in the documentation, which # will result in a user-defined paragraph with heading "Side Effects:". # You can put \n's in the value part of an alias to insert newlines. ALIASES = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C # sources only. Doxygen will then generate output that is more tailored for C. # For instance, some of the names that are used will be different. The list # of all members will be omitted, etc. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java # sources only. Doxygen will then generate output that is more tailored for Java. # For instance, namespaces will be presented as packages, qualified scopes # will look different, etc. OPTIMIZE_OUTPUT_JAVA = NO # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want to # include (a tag file for) the STL sources as input, then you should # set this tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); v.s. # func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. BUILTIN_STL_SUPPORT = NO # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. CPP_CLI_SUPPORT = NO # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES, then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. DISTRIBUTE_GROUP_DOC = NO # Set the SUBGROUPING tag to YES (the default) to allow class member groups of # the same type (for instance a group of public functions) to be put as a # subgroup of that type (e.g. under the Public Functions section). Set it to # NO to prevent subgrouping. Alternatively, this can be done per class using # the \nosubgrouping command. SUBGROUPING = YES #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in # documentation are documented, even if no documentation was available. # Private class members and static file members will be hidden unless # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES EXTRACT_ALL = YES # If the EXTRACT_PRIVATE tag is set to YES all private members of a class # will be included in the documentation. EXTRACT_PRIVATE = NO # If the EXTRACT_STATIC tag is set to YES all static members of a file # will be included in the documentation. EXTRACT_STATIC = NO # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) # defined locally in source files will be included in the documentation. # If set to NO only classes defined in header files are included. EXTRACT_LOCAL_CLASSES = YES # This flag is only useful for Objective-C code. When set to YES local # methods, which are defined in the implementation section but not in # the interface are included in the documentation. # If set to NO (the default) only methods in the interface are included. EXTRACT_LOCAL_METHODS = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all # undocumented members of documented classes, files or namespaces. # If set to NO (the default) these members will be included in the # various overviews, but no documentation section is generated. # This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_MEMBERS = NO # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. # If set to NO (the default) these classes will be included in the various # overviews. This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_CLASSES = NO # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all # friend (class|struct|union) declarations. # If set to NO (the default) these declarations will be included in the # documentation. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any # documentation blocks found inside the body of a function. # If set to NO (the default) these blocks will be appended to the # function's detailed documentation block. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation # that is typed after a \internal command is included. If the tag is set # to NO (the default) then the documentation will be excluded. # Set it to YES to include the internal documentation. INTERNAL_DOCS = YES # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate # file names in lower-case letters. If set to YES upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen # will show members with their full class and namespace scopes in the # documentation. If set to YES the scope will be hidden. HIDE_SCOPE_NAMES = NO # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen # will put a list of the files that are included by a file in the documentation # of that file. SHOW_INCLUDE_FILES = YES # If the INLINE_INFO tag is set to YES (the default) then a tag [inline] # is inserted in the documentation for inline members. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen # will sort the (detailed) documentation of file and class members # alphabetically by member name. If set to NO the members will appear in # declaration order. SORT_MEMBER_DOCS = NO # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the # brief documentation of file, namespace and class members alphabetically # by member name. If set to NO (the default) the members will appear in # declaration order. SORT_BRIEF_DOCS = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be # sorted by fully-qualified names, including namespaces. If set to # NO (the default), the class list will be sorted only by class name, # not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the # alphabetical list. SORT_BY_SCOPE_NAME = NO # The GENERATE_TODOLIST tag can be used to enable (YES) or # disable (NO) the todo list. This list is created by putting \todo # commands in the documentation. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable (YES) or # disable (NO) the test list. This list is created by putting \test # commands in the documentation. GENERATE_TESTLIST = YES # The GENERATE_BUGLIST tag can be used to enable (YES) or # disable (NO) the bug list. This list is created by putting \bug # commands in the documentation. GENERATE_BUGLIST = YES # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or # disable (NO) the deprecated list. This list is created by putting # \deprecated commands in the documentation. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional # documentation sections, marked by \if sectionname ... \endif. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines # the initial value of a variable or define consists of for it to appear in # the documentation. If the initializer consists of more lines than specified # here it will be hidden. Use a value of 0 to hide initializers completely. # The appearance of the initializer of individual variables and defines in the # documentation can be controlled using \showinitializer or \hideinitializer # command in the documentation regardless of this setting. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated # at the bottom of the documentation of classes and structs. If set to YES the # list will mention the files that were used to generate the documentation. SHOW_USED_FILES = YES # If the sources in your project are distributed over multiple directories # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy # in the documentation. The default is NO. SHOW_DIRECTORIES = NO # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from the # version control system). Doxygen will invoke the program by executing (via # popen()) the command , where is the value of # the FILE_VERSION_FILTER tag, and is the name of an input file # provided by doxygen. Whatever the program writes to standard output # is used as the file version. See the manual for examples. FILE_VERSION_FILTER = #--------------------------------------------------------------------------- # configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated # by doxygen. Possible values are YES and NO. If left blank NO is used. QUIET = NO # The WARNINGS tag can be used to turn on/off the warning messages that are # generated by doxygen. Possible values are YES and NO. If left blank # NO is used. WARNINGS = YES # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings # for undocumented members. If EXTRACT_ALL is set to YES then this flag will # automatically be disabled. WARN_IF_UNDOCUMENTED = YES # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some # parameters in a documented function, or documenting parameters that # don't exist or using markup commands wrongly. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be enabled to get warnings for # functions that are documented, but have no documentation for their parameters # or return value. If set to NO (the default) doxygen will only warn about # wrong or incomplete parameter documentation, but not about the absence of # documentation. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that # doxygen can produce. The string should contain the $file, $line, and $text # tags, which will be replaced by the file and line number from which the # warning originated and the warning text. Optionally the format may contain # $version, which will be replaced by the version of the file (if it could # be obtained via FILE_VERSION_FILTER) WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning # and error messages should be written. If left blank the output is written # to stderr. WARN_LOGFILE = #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag can be used to specify the files and/or directories that contain # documented source files. You may enter file names like "myfile.cpp" or # directories like "/usr/src/myproject". Separate the files or directories # with spaces. INPUT = .. # This tag can be used to specify the character encoding of the source files that # doxygen parses. Internally doxygen uses the UTF-8 encoding, which is also the default # input encoding. Doxygen uses libiconv (or the iconv built into libc) for the transcoding. # See http://www.gnu.org/software/libiconv for the list of possible encodings. INPUT_ENCODING = UTF-8 # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank the following patterns are tested: # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx # *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py FILE_PATTERNS = *.h \ *.c # The RECURSIVE tag can be used to turn specify whether or not subdirectories # should be searched for input files as well. Possible values are YES and NO. # If left blank NO is used. RECURSIVE = NO # The EXCLUDE tag can be used to specify files and/or directories that should # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. EXCLUDE = config.h # The EXCLUDE_SYMLINKS tag can be used select whether or not files or # directories that are symbolic links (a Unix filesystem feature) are excluded # from the input. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. Note that the wildcards are matched # against the file with absolute path, so to exclude all test directories # for example use the pattern */test/* EXCLUDE_PATTERNS = # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the output. # The symbol name can be a fully qualified name, a word, or if the wildcard * is used, # a substring. Examples: ANamespace, AClass, AClass::ANamespace, ANamespace::*Test EXCLUDE_SYMBOLS = # The EXAMPLE_PATH tag can be used to specify one or more files or # directories that contain example code fragments that are included (see # the \include command). EXAMPLE_PATH = # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank all files are included. EXAMPLE_PATTERNS = # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude # commands irrespective of the value of the RECURSIVE tag. # Possible values are YES and NO. If left blank NO is used. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or # directories that contain image that are included in the documentation (see # the \image command). IMAGE_PATH = # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command , where # is the value of the INPUT_FILTER tag, and is the name of an # input file. Doxygen will then use the output that the filter program writes # to standard output. If FILTER_PATTERNS is specified, this tag will be # ignored. INPUT_FILTER = # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. Doxygen will compare the file name with each pattern and apply the # filter if there is a match. The filters are a list of the form: # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further # info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER # is applied to all files. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER) will be used to filter the input files when producing source # files to browse (i.e. when SOURCE_BROWSER is set to YES). FILTER_SOURCE_FILES = NO #--------------------------------------------------------------------------- # configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will # be generated. Documented entities will be cross-referenced with these sources. # Note: To get rid of all source code in the generated output, make sure also # VERBATIM_HEADERS is set to NO. SOURCE_BROWSER = NO # Setting the INLINE_SOURCES tag to YES will include the body # of functions and classes directly in the documentation. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct # doxygen to hide any special comment blocks from generated source code # fragments. Normal C and C++ comments will always remain visible. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES (the default) # then for each documented function all documented # functions referencing it will be listed. REFERENCED_BY_RELATION = YES # If the REFERENCES_RELATION tag is set to YES (the default) # then for each documented function all documented entities # called/used by that function will be listed. REFERENCES_RELATION = YES # If the REFERENCES_LINK_SOURCE tag is set to YES (the default) # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will # link to the source code. Otherwise they will link to the documentation. REFERENCES_LINK_SOURCE = YES # If the USE_HTAGS tag is set to YES then the references to source code # will point to the HTML generated by the htags(1) tool instead of doxygen # built-in source browser. The htags tool is part of GNU's global source # tagging system (see http://www.gnu.org/software/global/global.html). You # will need version 4.8.6 or higher. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen # will generate a verbatim copy of the header file for each class for # which an include is specified. Set to NO to disable this. VERBATIM_HEADERS = YES #--------------------------------------------------------------------------- # configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index # of all compounds will be generated. Enable this if the project # contains a lot of classes, structs, unions or interfaces. ALPHABETICAL_INDEX = NO # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns # in which this list will be split (can be a number in the range [1..20]) COLS_IN_ALPHA_INDEX = 5 # In case all classes in a project start with a common prefix, all # classes will be put under the same header in the alphabetical index. # The IGNORE_PREFIX tag can be used to specify one or more prefixes that # should be ignored while generating the index headers. IGNORE_PREFIX = #--------------------------------------------------------------------------- # configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES (the default) Doxygen will # generate HTML output. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `html' will be used as the default path. HTML_OUTPUT = html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for # each generated HTML page (for example: .htm,.php,.asp). If it is left blank # doxygen will generate files with .html extension. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a personal HTML header for # each generated HTML page. If it is left blank doxygen will generate a # standard header. HTML_HEADER = # The HTML_FOOTER tag can be used to specify a personal HTML footer for # each generated HTML page. If it is left blank doxygen will generate a # standard footer. HTML_FOOTER = # The HTML_STYLESHEET tag can be used to specify a user-defined cascading # style sheet that is used by each HTML page. It can be used to # fine-tune the look of the HTML output. If the tag is left blank doxygen # will generate a default style sheet. Note that doxygen will try to copy # the style sheet file to the HTML output directory, so don't put your own # stylesheet in the HTML output directory as well, or it will be erased! HTML_STYLESHEET = # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, # files or namespaces will be aligned in HTML using tables. If set to # NO a bullet list will be used. HTML_ALIGN_MEMBERS = YES # If the GENERATE_HTMLHELP tag is set to YES, additional index files # will be generated that can be used as input for tools like the # Microsoft HTML help workshop to generate a compressed HTML help file (.chm) # of the generated HTML documentation. GENERATE_HTMLHELP = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can # be used to specify the file name of the resulting .chm file. You # can add a path in front of the file if the result should not be # written to the html output directory. CHM_FILE = # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can # be used to specify the location (absolute path including file name) of # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run # the HTML help compiler on the generated index.hhp. HHC_LOCATION = # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag # controls if a separate .chi index file is generated (YES) or that # it should be included in the master .chm file (NO). GENERATE_CHI = NO # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag # controls whether a binary table of contents is generated (YES) or a # normal table of contents (NO) in the .chm file. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members # to the contents of the HTML help documentation and to the tree view. TOC_EXPAND = NO # The DISABLE_INDEX tag can be used to turn on/off the condensed index at # top of each HTML page. The value NO (the default) enables the index and # the value YES disables it. DISABLE_INDEX = NO # This tag can be used to set the number of enum values (range [1..20]) # that doxygen will group on one line in the generated HTML documentation. ENUM_VALUES_PER_LINE = 4 # If the GENERATE_TREEVIEW tag is set to YES, a side panel will be # generated containing a tree-like index structure (just like the one that # is generated for HTML Help). For this to work a browser that supports # JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, # Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are # probably better off using the HTML help feature. GENERATE_TREEVIEW = NO # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be # used to set the initial width (in pixels) of the frame in which the tree # is shown. TREEVIEW_WIDTH = 250 #--------------------------------------------------------------------------- # configuration options related to the LaTeX output #--------------------------------------------------------------------------- # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will # generate Latex output. GENERATE_LATEX = NO # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `latex' will be used as the default path. LATEX_OUTPUT = latex # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be # invoked. If left blank `latex' will be used as the default command name. LATEX_CMD_NAME = latex # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to # generate index for LaTeX. If left blank `makeindex' will be used as the # default command name. MAKEINDEX_CMD_NAME = makeindex # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact # LaTeX documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_LATEX = NO # The PAPER_TYPE tag can be used to set the paper type that is used # by the printer. Possible values are: a4, a4wide, letter, legal and # executive. If left blank a4wide will be used. PAPER_TYPE = a4wide # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX # packages that should be included in the LaTeX output. EXTRA_PACKAGES = # The LATEX_HEADER tag can be used to specify a personal LaTeX header for # the generated latex document. The header should contain everything until # the first chapter. If it is left blank doxygen will generate a # standard header. Notice: only use this tag if you know what you are doing! LATEX_HEADER = # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated # is prepared for conversion to pdf (using ps2pdf). The pdf file will # contain links (just like the HTML output) instead of page references # This makes the output suitable for online browsing using a pdf viewer. PDF_HYPERLINKS = NO # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of # plain latex in the generated Makefile. Set this option to YES to get a # higher quality PDF documentation. USE_PDFLATEX = NO # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. # command to the generated LaTeX files. This will instruct LaTeX to keep # running if errors occur, instead of asking the user for help. # This option is also used when generating formulas in HTML. LATEX_BATCHMODE = NO # If LATEX_HIDE_INDICES is set to YES then doxygen will not # include the index chapters (such as File Index, Compound Index, etc.) # in the output. LATEX_HIDE_INDICES = NO #--------------------------------------------------------------------------- # configuration options related to the RTF output #--------------------------------------------------------------------------- # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output # The RTF output is optimized for Word 97 and may not look very pretty with # other RTF readers or editors. GENERATE_RTF = NO # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `rtf' will be used as the default path. RTF_OUTPUT = rtf # If the COMPACT_RTF tag is set to YES Doxygen generates more compact # RTF documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_RTF = NO # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated # will contain hyperlink fields. The RTF file will # contain links (just like the HTML output) instead of page references. # This makes the output suitable for online browsing using WORD or other # programs which support those fields. # Note: wordpad (write) and others do not support links. RTF_HYPERLINKS = NO # Load stylesheet definitions from file. Syntax is similar to doxygen's # config file, i.e. a series of assignments. You only have to provide # replacements, missing definitions are set to their default value. RTF_STYLESHEET_FILE = # Set optional variables used in the generation of an rtf document. # Syntax is similar to doxygen's config file. RTF_EXTENSIONS_FILE = #--------------------------------------------------------------------------- # configuration options related to the man page output #--------------------------------------------------------------------------- # If the GENERATE_MAN tag is set to YES (the default) Doxygen will # generate man pages GENERATE_MAN = YES # The MAN_OUTPUT tag is used to specify where the man pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `man' will be used as the default path. MAN_OUTPUT = man # The MAN_EXTENSION tag determines the extension that is added to # the generated man pages (default is the subroutine's section .3) MAN_EXTENSION = .3 # If the MAN_LINKS tag is set to YES and Doxygen generates man output, # then it will generate one additional man file for each entity # documented in the real man page(s). These additional files # only source the real man page, but without them the man command # would be unable to find the correct page. The default is NO. MAN_LINKS = NO #--------------------------------------------------------------------------- # configuration options related to the XML output #--------------------------------------------------------------------------- # If the GENERATE_XML tag is set to YES Doxygen will # generate an XML file that captures the structure of # the code including all documentation. GENERATE_XML = NO # The XML_OUTPUT tag is used to specify where the XML pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `xml' will be used as the default path. XML_OUTPUT = xml # The XML_SCHEMA tag can be used to specify an XML schema, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_SCHEMA = # The XML_DTD tag can be used to specify an XML DTD, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_DTD = # If the XML_PROGRAMLISTING tag is set to YES Doxygen will # dump the program listings (including syntax highlighting # and cross-referencing information) to the XML output. Note that # enabling this will significantly increase the size of the XML output. XML_PROGRAMLISTING = YES #--------------------------------------------------------------------------- # configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will # generate an AutoGen Definitions (see autogen.sf.net) file # that captures the structure of the code including all # documentation. Note that this feature is still experimental # and incomplete at the moment. GENERATE_AUTOGEN_DEF = NO #--------------------------------------------------------------------------- # configuration options related to the Perl module output #--------------------------------------------------------------------------- # If the GENERATE_PERLMOD tag is set to YES Doxygen will # generate a Perl module file that captures the structure of # the code including all documentation. Note that this # feature is still experimental and incomplete at the # moment. GENERATE_PERLMOD = NO # If the PERLMOD_LATEX tag is set to YES Doxygen will generate # the necessary Makefile rules, Perl scripts and LaTeX code to be able # to generate PDF and DVI output from the Perl module output. PERLMOD_LATEX = NO # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be # nicely formatted so it can be parsed by a human reader. This is useful # if you want to understand what is going on. On the other hand, if this # tag is set to NO the size of the Perl module output will be much smaller # and Perl will parse it just the same. PERLMOD_PRETTY = YES # The names of the make variables in the generated doxyrules.make file # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. # This is useful so different doxyrules.make files included by the same # Makefile don't overwrite each other's variables. PERLMOD_MAKEVAR_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will # evaluate all C-preprocessor directives found in the sources and include # files. ENABLE_PREPROCESSING = YES # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro # names in the source code. If set to NO (the default) only conditional # compilation will be performed. Macro expansion can be done in a controlled # way by setting EXPAND_ONLY_PREDEF to YES. MACRO_EXPANSION = NO # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES # then the macro expansion is limited to the macros specified with the # PREDEFINED and EXPAND_AS_DEFINED tags. EXPAND_ONLY_PREDEF = NO # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files # in the INCLUDE_PATH (see below) will be search if a #include is found. SEARCH_INCLUDES = YES # The INCLUDE_PATH tag can be used to specify one or more directories that # contain include files that are not input files but should be processed by # the preprocessor. INCLUDE_PATH = # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard # patterns (like *.h and *.hpp) to filter out the header-files in the # directories. If left blank, the patterns specified with FILE_PATTERNS will # be used. INCLUDE_FILE_PATTERNS = # The PREDEFINED tag can be used to specify one or more macro names that # are defined before the preprocessor is started (similar to the -D option of # gcc). The argument of the tag is a list of macros of the form: name # or name=definition (no spaces). If the definition and the = are # omitted =1 is assumed. To prevent a macro definition from being # undefined via #undef or recursively expanded use the := operator # instead of the = operator. PREDEFINED = # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then # this tag can be used to specify a list of macro names that should be expanded. # The macro definition that is found in the sources will be used. # Use the PREDEFINED tag if you want to use a different macro definition. EXPAND_AS_DEFINED = # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then # doxygen's preprocessor will remove all function-like macros that are alone # on a line, have an all uppercase name, and do not end with a semicolon. Such # function macros are typically used for boiler-plate code, and will confuse # the parser if not removed. SKIP_FUNCTION_MACROS = YES #--------------------------------------------------------------------------- # Configuration::additions related to external references #--------------------------------------------------------------------------- # The TAGFILES option can be used to specify one or more tagfiles. # Optionally an initial location of the external documentation # can be added for each tagfile. The format of a tag file without # this location is as follows: # TAGFILES = file1 file2 ... # Adding location for the tag files is done as follows: # TAGFILES = file1=loc1 "file2 = loc2" ... # where "loc1" and "loc2" can be relative or absolute paths or # URLs. If a location is present for each tag, the installdox tool # does not have to be run to correct the links. # Note that each tag file must have a unique name # (where the name does NOT include the path) # If a tag file is not located in the directory in which doxygen # is run, you must also specify the path to the tagfile here. TAGFILES = # When a file name is specified after GENERATE_TAGFILE, doxygen will create # a tag file that is based on the input files it reads. GENERATE_TAGFILE = # If the ALLEXTERNALS tag is set to YES all external classes will be listed # in the class index. If set to NO only the inherited external classes # will be listed. ALLEXTERNALS = NO # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed # in the modules index. If set to NO, only the current project's groups will # be listed. EXTERNAL_GROUPS = YES # The PERL_PATH should be the absolute path and name of the perl script # interpreter (i.e. the result of `which perl'). PERL_PATH = /usr/bin/perl #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base # or super classes. Setting the tag to NO turns the diagrams off. Note that # this option is superseded by the HAVE_DOT option below. This is only a # fallback. It is recommended to install and use dot, since it yields more # powerful graphs. CLASS_DIAGRAMS = YES # You can define message sequence charts within doxygen comments using the \msc # command. Doxygen will then run the mscgen tool (see http://www.mcternan.me.uk/mscgen/) to # produce the chart and insert it in the documentation. The MSCGEN_PATH tag allows you to # specify the directory where the mscgen tool resides. If left empty the tool is assumed to # be found in the default search path. MSCGEN_PATH = # If set to YES, the inheritance and collaboration graphs will hide # inheritance and usage relations if the target is undocumented # or is not a class. HIDE_UNDOC_RELATIONS = YES # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is # available from the path. This tool is part of Graphviz, a graph visualization # toolkit from AT&T and Lucent Bell Labs. The other options in this section # have no effect if this option is set to NO (the default) HAVE_DOT = NO # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect inheritance relations. Setting this tag to YES will force the # the CLASS_DIAGRAMS tag to NO. CLASS_GRAPH = YES # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect implementation dependencies (inheritance, containment, and # class references variables) of the class with other documented classes. COLLABORATION_GRAPH = YES # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen # will generate a graph for groups, showing the direct groups dependencies GROUP_GRAPHS = YES # If the UML_LOOK tag is set to YES doxygen will generate inheritance and # collaboration diagrams in a style similar to the OMG's Unified Modeling # Language. UML_LOOK = NO # If set to YES, the inheritance and collaboration graphs will show the # relations between templates and their instances. TEMPLATE_RELATIONS = NO # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT # tags are set to YES then doxygen will generate a graph for each documented # file showing the direct and indirect include dependencies of the file with # other documented files. INCLUDE_GRAPH = YES # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and # HAVE_DOT tags are set to YES then doxygen will generate a graph for each # documented header file showing the documented files that directly or # indirectly include this file. INCLUDED_BY_GRAPH = YES # If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will # generate a call dependency graph for every global function or class method. # Note that enabling this option will significantly increase the time of a run. # So in most cases it will be better to enable call graphs for selected # functions only using the \callgraph command. CALL_GRAPH = NO # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then doxygen will # generate a caller dependency graph for every global function or class method. # Note that enabling this option will significantly increase the time of a run. # So in most cases it will be better to enable caller graphs for selected # functions only using the \callergraph command. CALLER_GRAPH = NO # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen # will graphical hierarchy of all classes instead of a textual one. GRAPHICAL_HIERARCHY = YES # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES # then doxygen will show the dependencies a directory has on other directories # in a graphical way. The dependency relations are determined by the #include # relations between the files in the directories. DIRECTORY_GRAPH = YES # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images # generated by dot. Possible values are png, jpg, or gif # If left blank png will be used. DOT_IMAGE_FORMAT = png # The tag DOT_PATH can be used to specify the path where the dot tool can be # found. If left blank, it is assumed the dot tool can be found in the path. DOT_PATH = # The DOTFILE_DIRS tag can be used to specify one or more directories that # contain dot files that are included in the documentation (see the # \dotfile command). DOTFILE_DIRS = # The MAX_DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of # nodes that will be shown in the graph. If the number of nodes in a graph # becomes larger than this value, doxygen will truncate the graph, which is # visualized by representing a node as a red box. Note that doxygen will always # show the root nodes and its direct children regardless of this setting. DOT_GRAPH_MAX_NODES = 50 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent # background. This is disabled by default, which results in a white background. # Warning: Depending on the platform used, enabling this option may lead to # badly anti-aliased labels on the edges of a graph (i.e. they become hard to # read). DOT_TRANSPARENT = NO # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output # files in one run (i.e. multiple -o and -T options on the command line). This # makes dot run faster, but since only newer versions of dot (>1.8.10) # support this, this feature is disabled by default. DOT_MULTI_TARGETS = NO # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will # generate a legend page explaining the meaning of the various boxes and # arrows in the dot generated graphs. GENERATE_LEGEND = YES # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will # remove the intermediate dot files that are used to generate # the various graphs. DOT_CLEANUP = YES #--------------------------------------------------------------------------- # Configuration::additions related to the search engine #--------------------------------------------------------------------------- # The SEARCHENGINE tag specifies whether or not a search engine should be # used. If set to NO the values of all tags below this one will be ignored. SEARCHENGINE = NO memcached-1.6.20/doc/protocol-binary.full0000664000175000017500000020565014340006077015216 00000000000000 Memcache Binary Protocol Six Apart, Ltd.
548 4th Street San Francisco CA 94107 USA aaron@serendipity.palo-alto.ca.us
Sun Microsystems, INC
Haakon VII g. 7B Trondheim NO-7485 Trondheim Norway trond.norbye@sun.com
Applications memcache memcached cache This memo explains the memcache binary protocol for informational purposes. Memcache is a high performance key-value cache. It is intentionally a dumb cache, optimized for speed only. Applications using memcache do not rely on it for data -- a persistent database with guaranteed reliability is strongly recommended -- but applications can run much faster when cached data is available in memcache.
Memcache is a high performance key-value cache. It is intentionally a dumb cache, optimized for speed only. Applications using memcache should not rely on it for data -- a persistent database with guaranteed reliability is strongly recommended -- but applications can run much faster when cached data is available in memcache. Memcache was originally written to make LiveJournal faster. It now powers all of the fastest web sites that you love.
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in .
General format of a packet: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0/ HEADER / / / / / / / +---------------+---------------+---------------+---------------+ 24/ COMMAND-SPECIFIC EXTRAS (as needed) / +/ (note length in the extras length header field) / +---------------+---------------+---------------+---------------+ m/ Key (as needed) / +/ (note length in key length header field) / +---------------+---------------+---------------+---------------+ n/ Value (as needed) / +/ (note length is total body length header field, minus / +/ sum of the extras and key length body fields) / +---------------+---------------+---------------+---------------+ Total 24 bytes
Request header: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Magic | Opcode | Key length | +---------------+---------------+---------------+---------------+ 4| Extras length | Data type | Reserved | +---------------+---------------+---------------+---------------+ 8| Total body length | +---------------+---------------+---------------+---------------+ 12| Opaque | +---------------+---------------+---------------+---------------+ 16| CAS | | | +---------------+---------------+---------------+---------------+ Total 24 bytes
Response header: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Magic | Opcode | Key Length | +---------------+---------------+---------------+---------------+ 4| Extras length | Data type | Status | +---------------+---------------+---------------+---------------+ 8| Total body length | +---------------+---------------+---------------+---------------+ 12| Opaque | +---------------+---------------+---------------+---------------+ 16| CAS | | | +---------------+---------------+---------------+---------------+ Total 24 bytes
Header fields: Magic number. Command code. Length in bytes of the text key that follows the command extras. Status of the response (non-zero on error). Length in bytes of the command extras. Reserved for future use (Sean is using this soon). Really reserved for future use (up for grabs). Length in bytes of extra + key + value. Will be copied back to you in the response. Data version check.
Request packet for this protocol version Response packet for this protocol version Magic byte / version. For each version of the protocol, we'll use a different request/response value pair. This is useful for protocol analyzers to distinguish the nature of the packet from the direction which it is moving. Note, it is common to run a memcached instance on a host that also runs an application server. Such a host will both send and receive memcache packets. The version should hopefully correspond only to different meanings of the command byte. In an ideal world, we will not change the header format. As reserved bytes are given defined meaning, the protocol version / magic byte values should be incremented. Traffic analysis tools are encouraged to identify memcache packets and provide detailed interpretation if the magic bytes are recognized and otherwise to provide a generic breakdown of the packet. Note, that the key and value positions can always be identified even if the magic byte or command opcode are not recognized.
Possible values of this two-byte field: No error Key not found Key exists Value too large Invalid arguments Item not stored Incr/Decr on non-numeric value. Unknown command Out of memory
Possible values of the one-byte field: Get Set Add Replace Delete Increment Decrement Quit Flush GetQ No-op Version GetK GetKQ Append Prepend Stat SetQ AddQ ReplaceQ DeleteQ IncrementQ DecrementQ QuitQ FlushQ AppendQ PrependQ As a convention all of the commands ending with "Q" for Quiet. A quiet version of a command will omit responses that are considered uninteresting. Whether a given response is interesting is dependent upon the command. See the descriptions of the set commands and set commands for examples of commands that include quiet variants.
Possible values of the one-byte field: Raw bytes
All communication is initiated by a request from the client, and the server will respond to each request with zero or multiple packets for each request. If the status code of a response packet is non-nil, the body of the packet will contain a textual error message. If the status code is nil, the command opcode will define the layout of the body of the message.
The following figure illustrates the packet layout for a packet with an error message.
Packet layout: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x09 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x4e ('N') | 0x6f ('o') | 0x74 ('t') | 0x20 (' ') | +---------------+---------------+---------------+---------------+ 28| 0x66 ('f') | 0x6f ('o') | 0x75 ('u') | 0x6e ('n') | +---------------+---------------+---------------+---------------+ 32| 0x64 ('d') | +---------------+ Total 33 bytes (24 byte header, and 9 bytes value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x00 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0001 Total body (8-11) : 0x00000009 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value (24-32): The textual string "Not found"
Request: MUST NOT have extras. MUST have key. MUST NOT have value. Response (if found): MUST have extras. MAY have key. MAY have value. 4 byte flags
Extra data for the get commands: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Flags | +---------------+---------------+---------------+---------------+ Total 4 bytes
The get command gets a single key. The getq command is both mum on cache miss and quiet, holding its response until a non-quiet command is issued. Getk and getkq differs from get and getq by adding the key into the response packet. You're not guaranteed a response to a getq/getkq cache hit until you send a non-getq/getkq command later, which uncorks the server and bundles up IOs to send to the client in one go. Clients should implement multi-get (still important for reducing network roundtrips!) as n pipelined requests, the first n-1 being getq/getkq, the last being a regular get/getk. That way you're guaranteed to get a response, and you know when the server's done. You can also do the naive thing and send n pipelined get/getks, but then you could potentially get back a lot of "NOT_FOUND" error code packets. Alternatively, you can send 'n' getq/getkqs, followed by a 'noop' command.
To request the data associated with the key "Hello" the following fields must be specified in the packet.
get request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 28| 0x6f ('o') | +---------------+ Total 29 bytes (24 byte header, and 5 bytes key) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x00 Key length (2,3) : 0x0005 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000005 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key (24-29): The textual string: "Hello" Value : None
If the item exist on the server the following packet is returned, otherwise a packet with status code != 0 will be returned (see Introduction)
get/getq response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x04 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x09 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 24| 0xde | 0xad | 0xbe | 0xef | +---------------+---------------+---------------+---------------+ 28| 0x57 ('W') | 0x6f ('o') | 0x72 ('r') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 32| 0x64 ('d') | +---------------+ Total 33 bytes (24 byte header, 4 byte extras and 5 byte value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x00 Key length (2,3) : 0x0000 Extra length (4) : 0x04 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000009 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000001 Extras : Flags (24-27): 0xdeadbeef Key : None Value (28-32): The textual string "World"
getk/getkq response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x04 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x09 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 24| 0xde | 0xad | 0xbe | 0xef | +---------------+---------------+---------------+---------------+ 28| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 32| 0x6f ('o') | 0x57 ('W') | 0x6f ('o') | 0x72 ('r') | +---------------+---------------+---------------+---------------+ 36| 0x6c ('l') | 0x64 ('d') | +---------------+---------------+ Total 38 bytes (24 byte header, 4 byte extras, 5 byte key and 5 byte value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x00 Key length (2,3) : 0x0005 Extra length (4) : 0x04 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x0000000E Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000001 Extras : Flags (24-27): 0xdeadbeef Key (28-32): The textual string: "Hello" Value (33-37): The textual string: "World"
MUST have extras. MUST have key. MUST have value. 4 byte flags 4 byte expiration time
Extra data for set/add/replace: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Flags | +---------------+---------------+---------------+---------------+ 4| Expiration | +---------------+---------------+---------------+---------------+ Total 8 bytes
If the Data Version Check (CAS) is nonzero, the requested operation MUST only succeed if the item exists and has a CAS value identical to the provided value. Add MUST fail if the item already exist. Replace MUST fail if the item doesn't exist. Set should store the data unconditionally if the item exists or not. Quiet mutations only return responses on failure. Success is considered the general case and is suppressed when in quiet mode, but errors should not be allowed to go unnoticed.
The following figure shows an add-command for Key: "Hello" Value: "World" Flags: 0xdeadbeef Expiry: in two hours
Add request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x02 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x08 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x12 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0xde | 0xad | 0xbe | 0xef | +---------------+---------------+---------------+---------------+ 28| 0x00 | 0x00 | 0x1c | 0x20 | +---------------+---------------+---------------+---------------+ 32| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 36| 0x6f ('o') | 0x57 ('W') | 0x6f ('o') | 0x72 ('r') | +---------------+---------------+---------------+---------------+ 40| 0x6c ('l') | 0x64 ('d') | +---------------+---------------+ Total 42 bytes (24 byte header, 8 byte extras, 5 byte key and 5 byte value) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x02 Key length (2,3) : 0x0005 Extra length (4) : 0x08 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000012 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : Flags (24-27): 0xdeadbeef Expiry (28-31): 0x00001c20 Key (32-36): The textual string "Hello" Value (37-41): The textual string "World"
The response-packet contains no extra data, and the result of the operation is signaled through the status code. If the command succeeds, the CAS value for the item is returned in the CAS-field of the packet.
Successful add response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x02 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x02 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000001 Extras : None Key : None Value : None
MUST NOT have extras. MUST have key. MUST NOT have value. Delete the item with the specific key.
The following figure shows a delete message for the item "Hello".
Delete request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x04 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 28| 0x6f ('o') | +---------------+ Total 29 bytes (24 byte header, 5 byte value) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x04 Key length (2,3) : 0x0005 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000005 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : The textual string "Hello" Value : None
The response-packet contains no extra data, and the result of the operation is signaled through the status code.
MUST have extras. MUST have key. MUST NOT have value. 8 byte value to add / subtract 8 byte initial value (unsigned) 4 byte expiration time
Extra data for incr/decr: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Amount to add | | | +---------------+---------------+---------------+---------------+ 8| Initial value | | | +---------------+---------------+---------------+---------------+ 16| Expiration | +---------------+---------------+---------------+---------------+ Total 20 bytes
These commands will either add or remove the specified amount to the requested counter. If the counter does not exist, one of two things may happen: If the expiration value is all one-bits (0xffffffff), the operation will fail with NOT_FOUND. For all other expiration values, the operation will succeed by seeding the value for this key with the provided initial value to expire with the provided expiration time. The flags will be set to zero.
incr/decr response body: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 64-bit unsigned response. | | | +---------------+---------------+---------------+---------------+ Total 8 bytes
The following figure shows an incr-command for Key: "counter" Delta: 0x01 Initial: 0x00 Expiry: in two hours
Increment request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x05 | 0x00 | 0x07 | +---------------+---------------+---------------+---------------+ 4| 0x14 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x1b | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 28| 0x00 | 0x00 | 0x00 | 0x01 | +---------------+---------------+---------------+---------------+ 32| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 36| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 40| 0x00 | 0x00 | 0x1c | 0x20 | +---------------+---------------+---------------+---------------+ 44| 0x63 ('c') | 0x6f ('o') | 0x75 ('u') | 0x6e ('n') | +---------------+---------------+---------------+---------------+ 48| 0x74 ('t') | 0x65 ('e') | 0x72 ('r') | +---------------+---------------+---------------+ Total 51 bytes (24 byte header, 20 byte extras, 7 byte key) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x05 Key length (2,3) : 0x0007 Extra length (4) : 0x14 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x0000001b Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : delta (24-31): 0x0000000000000001 initial (32-39): 0x0000000000000000 expiration (40-43): 0x00001c20 Key : Textual string "counter" Value : None
If the key doesn't exist, the server will respond with the initial value. If not the incremented value will be returned. Let's assume that the key didn't exist, so the initial value is returned.
Increment response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x05 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x08 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 24| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 28| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 32 bytes (24 byte header, 8 byte value) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x05 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000008 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000005 Extras : None Key : None Value : 0x0000000000000000
MUST NOT have extras. MUST NOT have key. MUST NOT have value. Close the connection to the server.
Quit request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x07 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x07 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : None
The response-packet contains no extra data, and the result of the operation is signaled through the status code. The server will then close the connection.
MAY have extras. MUST NOT have key. MUST NOT have value. 4 byte expiration time
Extra data for flush: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| Expiration | +---------------+---------------+---------------+---------------+ Total 4 bytes
Flush the items in the cache now or some time in the future as specified by the expiration field. See the documentation of the textual protocol for the full description on how to specify the expiration time.
To flush the cache (delete all items) in two hours, the set the following values in the request
Flush request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x08 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x04 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x04 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x00 | 0x00 | 0x1c | 0x20 | +---------------+---------------+---------------+---------------+ Total 28 bytes (24 byte header, 4 byte body) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x08 Key length (2,3) : 0x0000 Extra length (4) : 0x04 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000004 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : Expiry (24-27): 0x00001c20 Key : None Value : None
The response-packet contains no extra data, and the result of the operation is signaled through the status code.
MUST NOT have extras. MUST NOT have key. MUST NOT have value. Used as a keep alive. Flushes outstanding getq/getkq's.
Noop request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x0a | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x0a Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : None
The response-packet contains no extra data, and the result of the operation is signaled through the status code.
MUST NOT have extras. MUST NOT have key. MUST NOT have value. Request the server version. The server responds with a packet containing the version string in the body with the following format: "x.y.z"
Version request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x0b | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x0b Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None
Version response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x0b | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x31 ('1') | 0x2e ('.') | 0x33 ('3') | 0x2e ('.') | +---------------+---------------+---------------+---------------+ 28| 0x31 ('1') | +---------------+ Total 29 bytes (24 byte header, 5 byte body) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x0b Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000005 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : Textual string "1.3.1"
MUST NOT have extras. MUST have key. MUST have value. These commands will either append or prepend the specified value to the requested key.
The following example appends '!' to the 'Hello' key.
Append request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x0e | 0x00 | 0x05 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x06 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x48 ('H') | 0x65 ('e') | 0x6c ('l') | 0x6c ('l') | +---------------+---------------+---------------+---------------+ 28| 0x6f ('o') | 0x21 ('!') | +---------------+---------------+ Total 30 bytes (24 byte header, 5 byte key, 1 byte value) Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x0e Key length (2,3) : 0x0005 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000006 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key (24-28): The textual string "Hello" Value (29) : "!"
The response-packet contains no extra data, and the result of the operation is signaled through the status code.
MUST NOT have extras. MAY have key. MUST NOT have value. Request server statistics. Without a key specified the server will respond with a "default" set of statistics information. Each piece of statistical information is returned in its own packet (key contains the name of the statistical item and the body contains the value in ASCII format). The sequence of return packets is terminated with a packet that contains no key and no value.
The following example requests all statistics from the server
Stat request: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x80 | 0x10 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ Total 24 bytes Field (offset) (value) Magic (0) : 0x80 Opcode (1) : 0x10 Key length (2,3) : 0x0000 Extra length (4) : 0x00 Data type (5) : 0x00 Reserved (6,7) : 0x0000 Total body (8-11) : 0x00000000 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : None Value : None
The server will send each value in a separate packet with an "empty" packet (no key / no value) to terminate the sequence. Each of the response packets look like the following example:
Stat response: Byte/ 0 | 1 | 2 | 3 | / | | | | |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7| +---------------+---------------+---------------+---------------+ 0| 0x81 | 0x10 | 0x00 | 0x03 | +---------------+---------------+---------------+---------------+ 4| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 8| 0x00 | 0x00 | 0x00 | 0x07 | +---------------+---------------+---------------+---------------+ 12| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 16| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 20| 0x00 | 0x00 | 0x00 | 0x00 | +---------------+---------------+---------------+---------------+ 24| 0x70 ('p') | 0x69 ('i') | 0x64 ('d') | 0x33 ('3') | +---------------+---------------+---------------+---------------+ 28| 0x30 ('0') | 0x37 ('7') | 0x38 ('8') | +---------------+---------------+---------------+ Total 31 bytes (24 byte header, 3 byte key, 4 byte body) Field (offset) (value) Magic (0) : 0x81 Opcode (1) : 0x10 Key length (2,3) : 0x0003 Extra length (4) : 0x00 Data type (5) : 0x00 Status (6,7) : 0x0000 Total body (8-11) : 0x00000007 Opaque (12-15): 0x00000000 CAS (16-23): 0x0000000000000000 Extras : None Key : The textual string "pid" Value : The textual string "3078"
Memcache has few authentication and no security layers whatsoever. It is RECOMMENDED that memcache be deployed strictly on closed, protected, back-end networks within a single data center, within a single cluster of servers, or even on a single host, providing shared caching for multiple applications. Memcache MUST NOT be made available on a public network. SASL is supported as an authentication mechanism. See the wiki for more information.
LJ NEEDS MOAR SPEED Danga Interactive http://www.livejournal.com/ Key words for use in RFCs to Indicate Requirement Levels Harvard University
1350 Mass. Ave. Cambridge MA 02138 - +1 617 495 3864 sob@harvard.edu
 General keyword In many standards track documents several words are used to signify the requirements in the specification. These words are often capitalized. This document defines these words as they should be interpreted in IETF documents. Authors who follow these guidelines should incorporate this phrase near the beginning of their document: The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119. Note that the force of these words is modified by the requirement level of the document in which they are used.
Thanks to Brad Fitzpatrick, Anatoly Vorobey, Steven Grimm, and Dustin Sallings, for their work on the memcached server. Thanks to Sean Chittenden, Jonathan Steinert, Brian Aker, Evan Martin, Nathan Neulinger, Eric Hodel, Michael Johnson, Paul Querna, Jamie McCarthy, Philip Neustrom, Andrew O'Brien, Josh Rotenberg, Robin H. Johnson, Tim Yardley, Paolo Borelli, Eli Bingham, Jean-Francois Bustarret, Paul G, Paul Lindner, Alan Kasindorf, Chris Goffinet, Tomash Brechko, and others for their work reporting bugs and maintaining memcached client libraries and bindings in many languages.
memcached-1.6.20/doc/xml2rfc/0000775000175000017500000000000014260436172012640 500000000000000memcached-1.6.20/doc/xml2rfc/rfc2629-refchk.xsl0000664000175000017500000000500613704126374015650 00000000000000 memcached-1.6.20/doc/xml2rfc/rfc2629.dtd0000664000175000017500000002211014260436172014346 00000000000000 %rfc2629-xhtml; %rfc2629-other; memcached-1.6.20/doc/xml2rfc/reference.RFC.0768.xml0000664000175000017500000000130013704126374016250 00000000000000 User Datagram Protocol University of Southern California (USC)/Information Sciences Institute
4676 Admiralty Way Marina del Rey CA 90291 US +1 213 822 1511
 memcached-1.6.20/doc/xml2rfc/rfc2629-xhtml.ent0000664000175000017500000003617013704126374015530 00000000000000 memcached-1.6.20/doc/xml2rfc/rfc2629-other.ent0000664000175000017500000000725413704126374015516 00000000000000 memcached-1.6.20/doc/xml2rfc/rfc2629-noinc.xsl0000664000175000017500000000601213704126374015512 00000000000000 .xml memcached-1.6.20/doc/xml2rfc/reference.RFC.2119.xml0000664000175000017500000000324013704126374016245 00000000000000 Key words for use in RFCs to Indicate Requirement Levels Harvard University
1350 Mass. Ave. Cambridge MA 02138 - +1 617 495 3864 sob@harvard.edu
 General keyword In many standards track documents several words are used to signify the requirements in the specification. These words are often capitalized. This document defines these words as they should be interpreted in IETF documents. Authors who follow these guidelines should incorporate this phrase near the beginning of their document: The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119. Note that the force of these words is modified by the requirement level of the document in which they are used. memcached-1.6.20/doc/Makefile.am0000664000175000017500000000150514340006077013234 00000000000000man_MANS = memcached.1 SPECIFICATIONS = protocol-binary.txt protocol-binary-range.txt EXTRA_DIST = $(srcdir)/*.txt # When we make dist always include the generated specifications so people don't # have to have xml2rfc and xsltproc installed EXTRA_DIST += $(SPECIFICATIONS) BUILT_SOURCES = MOSTLYCLEANFILES = #if BUILD_SPECIFICATIONS #BUILT_SOURCES += $(SPECIFICATIONS) #MOSTLYCLEANFILES += $(SPECIFICATIONS) #endif #RFC2629_XSL = $(srcdir)/xml2rfc/rfc2629-noinc.xsl #RFC2629_DTD = $(srcdir)/xml2rfc/rfc2629.dtd #%.txt: %.full $(RFC2629_DTD) # @XML2RFC@ -d $(RFC2629_DTD) -c $(builddir) $< $@ # #%.full: %.xml $(RFC2629_XSL) # @XSLTPROC@ --nonet $(RFC2629_XSL) $< > $@ # Prevent make from deleting intermediate files #all-full: $(SPECIFICATIONS:.txt=.full) #clean-local: # rm -f $(SPECIFICATIONS:.txt=.full) #.PHONY: all-full memcached-1.6.20/doc/protocol.txt0000664000175000017500000023767414427543277013642 00000000000000Protocol -------- Clients of memcached communicate with server through TCP connections. (A UDP interface is also available; details are below under "UDP protocol.") A given running memcached server listens on some (configurable) port; clients connect to that port, send commands to the server, read responses, and eventually close the connection. There is no need to send any command to end the session. A client may just close the connection at any moment it no longer needs it. Note, however, that clients are encouraged to cache their connections rather than reopen them every time they need to store or retrieve data. This is because memcached is especially designed to work very efficiently with a very large number (many hundreds, more than a thousand if necessary) of open connections. Caching connections will eliminate the overhead associated with establishing a TCP connection (the overhead of preparing for a new connection on the server side is insignificant compared to this). There are two kinds of data sent in the memcache protocol: text lines and unstructured data. Text lines are used for commands from clients and responses from servers. Unstructured data is sent when a client wants to store or retrieve data. The server will transmit back unstructured data in exactly the same way it received it, as a byte stream. The server doesn't care about byte order issues in unstructured data and isn't aware of them. There are no limitations on characters that may appear in unstructured data; however, the reader of such data (either a client or a server) will always know, from a preceding text line, the exact length of the data block being transmitted. Text lines are always terminated by \r\n. Unstructured data is _also_ terminated by \r\n, even though \r, \n or any other 8-bit characters may also appear inside the data. Therefore, when a client retrieves data from a server, it must use the length of the data block (which it will be provided with) to determine where the data block ends, and not the fact that \r\n follows the end of the data block, even though it does. Keys ---- Data stored by memcached is identified with the help of a key. A key is a text string which should uniquely identify the data for clients that are interested in storing and retrieving it. Currently the length limit of a key is set at 250 characters (of course, normally clients wouldn't need to use such long keys); the key must not include control characters or whitespace. Commands -------- There are three types of commands. Storage commands (there are six: "set", "add", "replace", "append" "prepend" and "cas") ask the server to store some data identified by a key. The client sends a command line, and then a data block; after that the client expects one line of response, which will indicate success or failure. Retrieval commands ("get", "gets", "gat", and "gats") ask the server to retrieve data corresponding to a set of keys (one or more keys in one request). The client sends a command line, which includes all the requested keys; after that for each item the server finds it sends to the client one response line with information about the item, and one data block with the item's data; this continues until the server finished with the "END" response line. All other commands don't involve unstructured data. In all of them, the client sends one command line, and expects (depending on the command) either one line of response, or several lines of response ending with "END" on the last line. A command line always starts with the name of the command, followed by parameters (if any) delimited by whitespace. Command names are lower-case and are case-sensitive. Meta Commands ------------- Meta commands are a set of new ASCII-based commands. They follow the same structure of the original commands but have a new flexible feature set. Meta commands incorporate most features available in the binary protocol, as well as a flag system to make the commands flexible rather than having a large number of high level commands. These commands completely replace the usage of basic Storage and Retrieval commands. Meta flags are not to be confused with client bitflags, which is an opaque number passed by the client. Meta flags change how the command operates, but they are not stored in cache. These work mixed with normal protocol commands on the same connection. All existing commands continue to work. The meta commands will not replace specialized commands that do not sit in the Storage or Retrieval categories noted in the 'Commands' section above. All meta commands follow a basic syntax: <...>\r\n Where is a 2 character command code. is only for commands with payloads, like set. Responses look like: <...>\r\n Where is a 2 character return code. The number of flags returned are based off of the flags supplied. is only for responses with payloads, with the return code 'VA'. Flags are single character codes, ie 'q' or 'k' or 'I', which adjust the behavior of the command. If a flag requests a response flag (ie 't' for TTL remaining), it is returned in the same order as they were in the original command, though this is not strict. Flags are single character codes, ie 'q' or 'k' or 'O', which adjust the behavior of a command. Flags may contain token arguments, which come after the flag and before the next space or newline, ie 'Oopaque' or 'Kuserkey'. Flags can return new data or reflect information, in the same order they were supplied in the request. Sending an 't' flag with a get for an item with 20 seconds of TTL remaining, would return 't20' in the response. All commands accept a tokens 'P' and 'L' which are completely ignored. The arguments to 'P' and 'L' can be used as hints or path specifications to a proxy or router inbetween a client and a memcached daemon. For example, a client may prepend a "path" in the key itself: "mg /path/foo v" or in a proxy token: "mg foo Lpath/ v" - the proxy may then optionally remove or forward the token to a memcached daemon, which will ignore them. Syntax errors are handled the same as noted under 'Error strings' section below. For usage examples beyond basic syntax, please see the wiki: https://github.com/memcached/memcached/wiki/MetaCommands Expiration times ---------------- Some commands involve a client sending some kind of expiration time (relative to an item or to an operation requested by the client) to the server. In all such cases, the actual value sent may either be Unix time (number of seconds since January 1, 1970, as a 32-bit value), or a number of seconds starting from current time. In the latter case, this number of seconds may not exceed 60*60*24*30 (number of seconds in 30 days); if the number sent by a client is larger than that, the server will consider it to be real Unix time value rather than an offset from current time. Note that a TTL of 1 will sometimes immediately expire. Time is internally updated on second boundaries, which makes expiration time roughly +/- 1s. This more proportionally affects very low TTL's. Error strings ------------- Each command sent by a client may be answered with an error string from the server. These error strings come in three types: - "ERROR\r\n" means the client sent a nonexistent command name. - "CLIENT_ERROR \r\n" means some sort of client error in the input line, i.e. the input doesn't conform to the protocol in some way. is a human-readable error string. - "SERVER_ERROR \r\n" means some sort of server error prevents the server from carrying out the command. is a human-readable error string. In cases of severe server errors, which make it impossible to continue serving the client (this shouldn't normally happen), the server will close the connection after sending the error line. This is the only case in which the server closes a connection to a client. In the descriptions of individual commands below, these error lines are not again specifically mentioned, but clients must allow for their possibility. Authentication -------------- Optional username/password token authentication (see -Y option). Used by sending a fake "set" command with any key: set \r\n username password\r\n key, flags, and exptime are ignored for authentication. Bytes is the length of the username/password payload. - "STORED\r\n" indicates success. After this point any command should work normally. - "CLIENT_ERROR [message]\r\n" will be returned if authentication fails for any reason. Storage commands ---------------- First, the client sends a command line which looks like this: [noreply]\r\n cas [noreply]\r\n - is "set", "add", "replace", "append" or "prepend" "set" means "store this data". "add" means "store this data, but only if the server *doesn't* already hold data for this key". "replace" means "store this data, but only if the server *does* already hold data for this key". "append" means "add this data to an existing key after existing data". "prepend" means "add this data to an existing key before existing data". The append and prepend commands do not accept flags or exptime. They update existing data portions, and ignore new flag and exptime settings. "cas" is a check and set operation which means "store this data but only if no one else has updated since I last fetched it." - is the key under which the client asks to store the data - is an arbitrary 16-bit unsigned integer (written out in decimal) that the server stores along with the data and sends back when the item is retrieved. Clients may use this as a bit field to store data-specific information; this field is opaque to the server. Note that in memcached 1.2.1 and higher, flags may be 32-bits, instead of 16, but you might want to restrict yourself to 16 bits for compatibility with older versions. - is expiration time. If it's 0, the item never expires (although it may be deleted from the cache to make place for other items). If it's non-zero (either Unix time or offset in seconds from current time), it is guaranteed that clients will not be able to retrieve this item after the expiration time arrives (measured by server time). If a negative value is given the item is immediately expired. - is the number of bytes in the data block to follow, *not* including the delimiting \r\n. may be zero (in which case it's followed by an empty data block). - is a unique 64-bit value of an existing entry. Clients should use the value returned from the "gets" command when issuing "cas" updates. - "noreply" optional parameter instructs the server to not send the reply. NOTE: if the request line is malformed, the server can't parse "noreply" option reliably. In this case it may send the error to the client, and not reading it on the client side will break things. Client should construct only valid requests. After this line, the client sends the data block: \r\n - is a chunk of arbitrary 8-bit data of length from the previous line. After sending the command line and the data block the client awaits the reply, which may be: - "STORED\r\n", to indicate success. - "NOT_STORED\r\n" to indicate the data was not stored, but not because of an error. This normally means that the condition for an "add" or a "replace" command wasn't met. - "EXISTS\r\n" to indicate that the item you are trying to store with a "cas" command has been modified since you last fetched it. - "NOT_FOUND\r\n" to indicate that the item you are trying to store with a "cas" command did not exist. Retrieval command: ------------------ The retrieval commands "get" and "gets" operate like this: get *\r\n gets *\r\n - * means one or more key strings separated by whitespace. After this command, the client expects zero or more items, each of which is received as a text line followed by a data block. After all the items have been transmitted, the server sends the string "END\r\n" to indicate the end of response. Each item sent by the server looks like this: VALUE []\r\n \r\n - is the key for the item being sent - is the flags value set by the storage command - is the length of the data block to follow, *not* including its delimiting \r\n - is a unique 64-bit integer that uniquely identifies this specific item. - is the data for this item. If some of the keys appearing in a retrieval request are not sent back by the server in the item list this means that the server does not hold items with such keys (because they were never stored, or stored but deleted to make space for more items, or expired, or explicitly deleted by a client). Deletion -------- The command "delete" allows for explicit deletion of items: delete [noreply]\r\n - is the key of the item the client wishes the server to delete - "noreply" optional parameter instructs the server to not send the reply. See the note in Storage commands regarding malformed requests. The response line to this command can be one of: - "DELETED\r\n" to indicate success - "NOT_FOUND\r\n" to indicate that the item with this key was not found. See the "flush_all" command below for immediate invalidation of all existing items. Increment/Decrement ------------------- Commands "incr" and "decr" are used to change data for some item in-place, incrementing or decrementing it. The data for the item is treated as decimal representation of a 64-bit unsigned integer. If the current data value does not conform to such a representation, the incr/decr commands return an error (memcached <= 1.2.6 treated the bogus value as if it were 0, leading to confusion). Also, the item must already exist for incr/decr to work; these commands won't pretend that a non-existent key exists with value 0; instead, they will fail. The client sends the command line: incr [noreply]\r\n or decr [noreply]\r\n - is the key of the item the client wishes to change - is the amount by which the client wants to increase/decrease the item. It is a decimal representation of a 64-bit unsigned integer. - "noreply" optional parameter instructs the server to not send the reply. See the note in Storage commands regarding malformed requests. The response will be one of: - "NOT_FOUND\r\n" to indicate the item with this value was not found - \r\n , where is the new value of the item's data, after the increment/decrement operation was carried out. Note that underflow in the "decr" command is caught: if a client tries to decrease the value below 0, the new value will be 0. Overflow in the "incr" command will wrap around the 64 bit mark. Note also that decrementing a number such that it loses length isn't guaranteed to decrement its returned length. The number MAY be space-padded at the end, but this is purely an implementation optimization, so you also shouldn't rely on that. Touch ----- The "touch" command is used to update the expiration time of an existing item without fetching it. touch [noreply]\r\n - is the key of the item the client wishes the server to touch - is expiration time. Works the same as with the update commands (set/add/etc). This replaces the existing expiration time. If an existing item were to expire in 10 seconds, but then was touched with an expiration time of "20", the item would then expire in 20 seconds. - "noreply" optional parameter instructs the server to not send the reply. See the note in Storage commands regarding malformed requests. The response line to this command can be one of: - "TOUCHED\r\n" to indicate success - "NOT_FOUND\r\n" to indicate that the item with this key was not found. Get And Touch ------------- The "gat" and "gats" commands are used to fetch items and update the expiration time of an existing items. gat *\r\n gats *\r\n - is expiration time. - * means one or more key strings separated by whitespace. After this command, the client expects zero or more items, each of which is received as a text line followed by a data block. After all the items have been transmitted, the server sends the string "END\r\n" to indicate the end of response. Each item sent by the server looks like this: VALUE []\r\n \r\n - is the key for the item being sent - is the flags value set by the storage command - is the length of the data block to follow, *not* including its delimiting \r\n - is a unique 64-bit integer that uniquely identifies this specific item. - is the data for this item. Meta Debug ---------- The meta debug command is a human readable dump of all available internal metadata of an item, minus the value. me \r\n - means one key string. - if is 'b', then is a base64 encoded binary value. the response key will also be base64 encoded. The response looks like: ME =*\r\n A miss looks like: EN\r\n Each of the keys and values are the internal data for the item. exp = expiration time la = time in seconds since last access cas = CAS ID fetch = whether an item has been fetched before cls = slab class id size = total size in bytes Others may be added. Meta Get -------- The meta get command is the generic command for retrieving key data from memcached. Based on the flags supplied, it can replace all of the commands: "get", "gets", "gat", "gats", "touch", as well as adding new options. mg *\r\n - means one key string. Unlike "get" metaget can only take a single key. - are a set of single character codes ended with a space or newline. flags may have token strings after the initial character. After this command, the client expects an item to be returned, received as a text line followed by an optional data block. If a response line appearing in a retrieval request is not sent back by the server this means that the server does not have the item (because it was never stored, or stored but deleted to make space for more items, or expired, or explicitly deleted by a client). An item sent by the server looks like: VA *\r\n \r\n - is the size of in bytes, minus the \r\n - * are flags returned by the server, based on the command flags. They are added in order specified by the flags sent. - is the data for this item. Note that the data block is optional, requiring the 'v' flag to be supplied. If the request did not ask for a value in the response (v) flag, the server response looks like: HD *\r\n If the request resulted in a miss, the response looks like: EN\r\n Unless the (q) flag was supplied, which suppresses the status code for a miss. The flags used by the 'mg' command are: - b: interpret key as base64 encoded binary value - c: return item cas token - f: return client flags token - h: return whether item has been hit before as a 0 or 1 - k: return key as a token - l: return time since item was last accessed in seconds - O(token): opaque value, consumes a token and copies back with response - q: use noreply semantics for return codes. - s: return item size token - t: return item TTL remaining in seconds (-1 for unlimited) - u: don't bump the item in the LRU - v: return item value in These flags can modify the item: - N(token): vivify on miss, takes TTL as a argument - R(token): if token is less than remaining TTL win for recache - T(token): update remaining TTL These extra flags can be added to the response: - W: client has "won" the recache flag - X: item is stale - Z: item has already sent a winning flag The flags are now repeated with detailed information where useful: - b: interpret key as base64 encoded binary value This flag instructs memcached to run a base64 decoder on before looking it up. This allows storing and fetching of binary packed keys, so long as they are sent to memcached in base64 encoding. If 'b' flag is sent in the response, and a key is returned via 'k', this signals to the client that the key is base64 encoded binary. - h: return whether item has been hit before as a 0 or 1 - l: return time since item was last accessed in seconds The above two flags return the value of "hit before?" and "last access time" before the command was processed. Otherwise this would always show a 1 for hit or always show an access time of "0" unless combined with the "u" flag. - O(token): opaque value, consumes a token and copies back with response The O(opaque) token is used by this and other commands to allow easier pipelining of requests while saving bytes on the wire for responses. For example: if pipelining three get commands together, you may not know which response belongs to which without also retrieving the key. If the key is very long this can generate a lot of traffic, especially if the data block is very small. Instead, you can supply an "O" flag for each mg with tokens of "1" "2" and "3", to match up responses to the request. Opaque tokens may be up to 32 bytes in length, and are a string similar to keys. - q: use noreply semantics for return codes. Noreply is a method of reducing the amount of data sent back by memcached to the client for normal responses. In the case of metaget, if an item is not available the "VA" line is normally not sent, and the response is terminated by "EN\r\n". With noreply enabled, the "EN\r\n" marker is suppressed. This allows you to pipeline several mg's together and read all of the responses without the "EN\r\n" lines in the middle. Errors are always returned. - u: don't bump the item in the LRU It is possible to access an item without causing it to be "bumped" to the head of the LRU. This also avoids marking an item as being hit or updating its last access time. - v: return item value in The data block for a metaget response is optional, requiring this flag to be passed in. The response code also changes from "HD" to "VA " These flags can modify the item: - N(token): vivify on miss, takes TTL as a argument Used to help with so called "dog piling" problems with recaching of popular items. If supplied, and metaget does not find the item in cache, it will create a stub item with the key and TTL as supplied. If such an item is created a 'W' flag is added to the response to indicate to a client that they have "won" the right to recache an item. The automatically created item has 0 bytes of data. Further requests will see a 'Z' flag to indicate that another client has already received the win flag. Can be combined with CAS flags to gate the update further. - R(token): if token is less than remaining TTL win for recache Similar to and can be combined with 'N'. If the remaining TTL of an item is below the supplied token, return a 'W' flag to indicate the client has "won" the right to recache an item. This allows refreshing an item before it leads to a miss. - T(token): update remaining TTL Similar to "touch" and "gat" commands, updates the remaining TTL of an item if hit. These extra flags can be added to the response: - W: client has "won" the recache flag When combined with N or R flags, a client may be informed they have "won" ownership of a cache item. This allows a single client to be atomically notified that it should cache or update an item. Further clients requesting the item can use the existing data block (if valid or stale), retry, wait, or take some other action while the item is missing. This is used when the act of recaching an item can cause undue load on another system (CPU, database accesses, time, and so on). - X: item is stale Items can be marked as stale by the metadelete command. This indicates to the client that an object needs to be updated, and that it should make a decision o if potentially stale data is safe to use. This is used when you want to convince clients to recache an item, but it's safe to use pre-existing data while the recache happens. - Z: item has already sent a winning flag When combined with the X flag, or the client N or R flags, this extra response flag indicates to a client that a different client is responsible for recaching this item. If there is data supplied it may use it, or the client may decide to retry later or take some other action. Meta Set -------- The meta set command a generic command for storing data to memcached. Based on the flags supplied, it can replace all storage commands (see token M) as well as adds new options. ms *\r\n - means one key string. - is the length of the payload data. - are a set of single character codes ended with a space or newline. flags may have strings after the initial character. After this line, the client sends the data block: \r\n - is a chunk of arbitrary 8-bit data of length supplied by an 'S' flag and token from the request line. If no 'S' flag is supplied the data is assumed to be 0 length. After sending the command line and the data block the client awaits the reply, which is of the format: *\r\n Where CD is one of: - "HD" (STORED), to indicate success. - "NS" (NOT_STORED), to indicate the data was not stored, but not because of an error. - "EX" (EXISTS), to indicate that the item you are trying to store with CAS semantics has been modified since you last fetched it. - "NF" (NOT_FOUND), to indicate that the item you are trying to store with CAS semantics did not exist. The flags used by the 'ms' command are: - b: interpret key as base64 encoded binary value (see metaget) - c: return CAS value if successfully stored. - C(token): compare CAS value when storing item - F(token): set client flags to token (32 bit unsigned numeric) - I: invalidate. set-to-invalid if supplied CAS is older than item's CAS - k: return key as a token - O(token): opaque value, consumes a token and copies back with response - q: use noreply semantics for return codes - s: return the size of the stored item on success (ie; new size on append) - T(token): Time-To-Live for item, see "Expiration" above. - M(token): mode switch to change behavior to add, replace, append, prepend - N(token): if in append mode, autovivify on miss with supplied TTL The flags are now repeated with detailed information where useful: - c: returns the CAS value on successful storage. Will return 0 on error, but clients must not depend on the return value being zero. In future versions this may return the current CAS value for "EX" return code conditions. - C(token): compare CAS value when storing item Similar to the basic "cas" command, only store item if the supplied token matches the current CAS value of the item. When combined with the 'I' flag, a CAS value that is _lower_ than the current value may be accepted, but the item will be marked as "stale", returning the X flag with mget requests. - F(token): set client flags to token (32 bit unsigned numeric) Sets flags to 0 if not supplied. - I: invalid. set-to-invalid if CAS is older than it should be. Functional when combined with 'C' flag above. - O(token): opaque value, consumes a token and copies back with response See description under 'Meta Get' - q: use noreply semantics for return codes Noreply is a method of reducing the amount of data sent back by memcached to the client for normal responses. In the case of metaset, a response that would start with "HD" will not be sent. Any other code, such as "EX" (EXISTS) will still be returned. Errors are always returned. - M(token): mode switch. Takes a single character for the mode. E: "add" command. LRU bump and return NS if item exists. Else add. A: "append" command. If item exists, append the new value to its data. P: "prepend" command. If item exists, prepend the new value to its data. R: "replace" command. Set only if item already exists. S: "set" command. The default mode, added for completeness. The "cas" command is supplanted by specifying the cas value with the 'C' flag. Append and Prepend modes will also respect a supplied cas value. - N(token): if in append mode, autovivify on miss with supplied TTL Append and Prepend modes normally ignore the T argument, as they cannot create a new item on a miss. If N is supplied, and append reaches a miss, it will create a new item seeded with the data from the append command. It uses the TTL from N instead of T to be consistent with the usage of N in other commands. Meta Delete ----------- The meta delete command allows for explicit deletion of items, as well as marking items as "stale" to allow serving items as stale during revalidation. md *\r\n - means one key string. - are a set of single character codes ended with a space or newline. flags may have strings after the initial character. The response is in the format: *\r\n Where CD is one of: - "HD" (DELETED), to indicate success - "NF" (NOT_FOUND), to indicate that the item with this key was not found. - "EX" (EXISTS), to indicate that the supplied CAS token does not match the stored item. The flags used by the 'md' command are: - b: interpret key as base64 encoded binary value (see metaget) - C(token): compare CAS value - I: invalidate. mark as stale, bumps CAS. - k: return key - O(token): opaque to copy back. - q: noreply - T(token): updates TTL, only when paired with the 'I' flag The flags are now repeated with detailed information where useful: - C(token): compare CAS value Can be used to only delete or mark-stale if a supplied CAS value matches. - I: invalidate. mark as stale, bumps CAS. Instead of removing an item, this will give the item a new CAS value and mark it as stale. This means when it is later fetched by metaget, the client will be supplied an 'X' flag to show the data is stale and needs to be recached. - O(token): opaque to copy back. See description under 'Meta Get' - q: noreply See description under 'Meta Set'. In the case of meta delete, this will hide response lines with the code "DE". It will still return any other responses. - T(token): updates TTL, only when paired with the 'I' flag When marking an item as stale with 'I', the 'T' flag can be used to update the TTL as well; limiting the amount of time an item will live while stale and waiting to be recached. Meta Arithmetic --------------- The meta arithmetic command allows for basic operations against numerical values. This replaces the "incr" and "decr" commands. Values are unsigned 64bit integers. Decrementing will reach 0 rather than underflow. Incrementing can overflow. ma *\r\n - means one key string. - are a set of single character codes ended with a space or newline. flags may have strings after the initial character. The response is in the format: *\r\n Where CD is one of: - "HD" to indicate success - "NF" (NOT_FOUND), to indicate that the item with this key was not found. - "NS" (NOT_STORED), to indicate that the item was not created as requested after a miss. - "EX" (EXISTS), to indicate that the supplied CAS token does not match the stored item. If the 'v' flag is supplied, the response is formatted as: VA *\r\n \r\n The flags used by the 'ma' command are: - b: interpret key as base64 encoded binary value (see metaget) - C(token): compare CAS value (see mset) - N(token): auto create item on miss with supplied TTL - J(token): initial value to use if auto created after miss (default 0) - D(token): delta to apply (decimal unsigned 64-bit number, default 1) - T(token): update TTL on success - M(token): mode switch to change between incr and decr modes. - O(token): opaque value, consumes a token and copies back with response - q: use noreply semantics for return codes (see details under mset) - t: return current TTL - c: return current CAS value if successful. - v: return new value - k: return key as a token The flags are now repeated with detailed information where useful: - C(token): compare CAS value Can be used to only incr/decr if a supplied CAS value matches. A new CAS value is generated after a delta is applied. Add the 'c' flag to get the new CAS value after success. - N(token): auto create item on miss with supplied TTL Similar to mget, on a miss automatically create the item. A value can be seeded using the J flag. - J(token): initial value An unsigned 64-bit integer which will be seeded as the value on a miss. Must be combined with an N flag. - D(token): delta to apply An unsigned integer to either add or subtract from the currently stored number. - T(token): update TTL On success, sets the remaining TTL to the supplied value. -M(token): mode switch. Takes a single character for the mode. I: Increment mode (default) +: Alias for increment D: Decrement mode -: Alias for decrement Meta No-Op ---------- The meta no-op command exists solely to return a static response code. It takes no flags, no arguments. "mn\r\n" This returns the static response: "MN\r\n" This command is useful when used with the 'q' flag and pipelining commands. For example, with 'mg' the response lines are blank on miss when the 'q' flag is supplied. If pipelining several 'mg's together with noreply semantics, an "mn\r\n" command can be tagged to the end of the chain, which will return an "MN\r\n", signalling to a client that all previous commands have been processed. Slabs Reassign -------------- NOTE: This command is subject to change as of this writing. The slabs reassign command is used to redistribute memory once a running instance has hit its limit. It might be desirable to have memory laid out differently than was automatically assigned after the server started. slabs reassign \r\n - is an id number for the slab class to steal a page from A source class id of -1 means "pick from any valid class" - is an id number for the slab class to move a page to The response line could be one of: - "OK" to indicate the page has been scheduled to move - "BUSY [message]" to indicate a page is already being processed, try again later. - "BADCLASS [message]" a bad class id was specified - "NOSPARE [message]" source class has no spare pages - "NOTFULL [message]" dest class must be full to move new pages to it - "UNSAFE [message]" source class cannot move a page right now - "SAME [message]" must specify different source/dest ids. Slabs Automove -------------- NOTE: This command is subject to change as of this writing. The slabs automove command enables a background thread which decides on its own when to move memory between slab classes. Its implementation and options will likely be in flux for several versions. See the wiki/mailing list for more details. The automover can be enabled or disabled at runtime with this command. slabs automove <0|1> - 0|1|2 is the indicator on whether to enable the slabs automover or not. The response should always be "OK\r\n" - <0> means to set the thread on standby - <1> means to return pages to a global pool when there are more than 2 pages worth of free chunks in a slab class. Pages are then re-assigned back into other classes as-needed. - <2> is a highly aggressive mode which causes pages to be moved every time there is an eviction. It is not recommended to run for very long in this mode unless your access patterns are very well understood. LRU Tuning ---------- Memcached supports multiple LRU algorithms, with a few tunables. Effort is made to have sane defaults however you are able to tune while the daemon is running. The traditional model is "flat" mode, which is a single LRU chain per slab class. The newer (with `-o modern` or `-o lru_maintainer`) is segmented into HOT, WARM, COLD. There is also a TEMP LRU. See doc/new_lru.txt for details. lru