Debian Codegraph @

plugin/innodb_memcached/daemon_memcached/engines/default_engine/default_engine.c

raw
1 /* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2 #include "config.h"
3
4 #include <stdlib.h>
5 #include <stdio.h>
6 #include <string.h>
7 #include <assert.h>
8 #include <errno.h>
9 #include <ctype.h>
10 #include <unistd.h>
11 #include <stddef.h>
12 #include <inttypes.h>
13
14 #include "default_engine.h"
15 #include "memcached/util.h"
16 #include "memcached/config_parser.h"
17
18 static const engine_info* default_get_info(ENGINE_HANDLE* handle);
19 static ENGINE_ERROR_CODE default_initialize(ENGINE_HANDLE* handle,
20 const char* config_str);
21 static void default_destroy(ENGINE_HANDLE* handle,
22 const bool force);
23 static ENGINE_ERROR_CODE default_item_allocate(ENGINE_HANDLE* handle,
24 const void* cookie,
25 item **item,
26 const void* key,
27 const size_t nkey,
28 const size_t nbytes,
29 const int flags,
30 const rel_time_t exptime);
31 static ENGINE_ERROR_CODE default_item_delete(ENGINE_HANDLE* handle,
32 const void* cookie,
33 const void* key,
34 const size_t nkey,
35 uint64_t cas,
36 uint16_t vbucket);
37
38 static void default_item_release(ENGINE_HANDLE* handle, const void *cookie,
39 item* item);
40 static ENGINE_ERROR_CODE default_get(ENGINE_HANDLE* handle,
41 const void* cookie,
42 item** item,
43 const void* key,
44 const int nkey,
45 uint16_t vbucket);
46 static ENGINE_ERROR_CODE default_get_stats(ENGINE_HANDLE* handle,
47 const void *cookie,
48 const char *stat_key,
49 int nkey,
50 ADD_STAT add_stat);
51 static void default_reset_stats(ENGINE_HANDLE* handle, const void *cookie);
52 static ENGINE_ERROR_CODE default_store(ENGINE_HANDLE* handle,
53 const void *cookie,
54 item* item,
55 uint64_t *cas,
56 ENGINE_STORE_OPERATION operation,
57 uint16_t vbucket);
58 static ENGINE_ERROR_CODE default_arithmetic(ENGINE_HANDLE* handle,
59 const void* cookie,
60 const void* key,
61 const int nkey,
62 const bool increment,
63 const bool create,
64 const uint64_t delta,
65 const uint64_t initial,
66 const rel_time_t exptime,
67 uint64_t *cas,
68 uint64_t *result,
69 uint16_t vbucket);
70 static ENGINE_ERROR_CODE default_flush(ENGINE_HANDLE* handle,
71 const void* cookie, time_t when);
72 static ENGINE_ERROR_CODE initalize_configuration(struct default_engine *se,
73 const char *cfg_str);
74 static ENGINE_ERROR_CODE default_unknown_command(ENGINE_HANDLE* handle,
75 const void* cookie,
76 protocol_binary_request_header *request,
77 ADD_RESPONSE response);
78
79 static ENGINE_ERROR_CODE default_tap_notify(ENGINE_HANDLE* handle,
80 const void *cookie,
81 void *engine_specific,
82 uint16_t nengine,
83 uint8_t ttl,
84 uint16_t tap_flags,
85 tap_event_t tap_event,
86 uint32_t tap_seqno,
87 const void *key,
88 size_t nkey,
89 uint32_t flags,
90 uint32_t exptime,
91 uint64_t cas,
92 const void *data,
93 size_t ndata,
94 uint16_t vbucket);
95
96 static TAP_ITERATOR default_get_tap_iterator(ENGINE_HANDLE* handle,
97 const void* cookie,
98 const void* client,
99 size_t nclient,
100 uint32_t flags,
101 const void* userdata,
102 size_t nuserdata);
103
104 static void default_handle_disconnect(const void *cookie,
105 ENGINE_EVENT_TYPE type,
106 const void *event_data,
107 const void *cb_data);
108
109 union vbucket_info_adapter {
110 char c;
111 struct vbucket_info v;
112 };
113
114 static void set_vbucket_state(struct default_engine *e,
115 uint16_t vbid, vbucket_state_t to) {
116 union vbucket_info_adapter vi;
117 vi.c = e->vbucket_infos[vbid];
118 vi.v.state = to;
119 e->vbucket_infos[vbid] = vi.c;
120 }
121
122 static vbucket_state_t get_vbucket_state(struct default_engine *e,
123 uint16_t vbid) {
124 union vbucket_info_adapter vi;
125 vi.c = e->vbucket_infos[vbid];
126 return vi.v.state;
127 }
128
129 static bool handled_vbucket(struct default_engine *e, uint16_t vbid) {
130 return e->config.ignore_vbucket
131 || (get_vbucket_state(e, vbid) == vbucket_state_active);
132 }
133
134 /* mechanism for handling bad vbucket requests */
135 #define VBUCKET_GUARD(e, v) if (!handled_vbucket(e, v)) { return ENGINE_NOT_MY_VBUCKET; }
136
137 static bool get_item_info(ENGINE_HANDLE *handle, const void *cookie,
138 const item* item, item_info *item_info);
139
140 static const char const * vbucket_state_name(vbucket_state_t s) {
141 static const char const * vbucket_states[] = {
142 [vbucket_state_active] = "active",
143 [vbucket_state_replica] = "replica",
144 [vbucket_state_pending] = "pending",
145 [vbucket_state_dead] = "dead"
146 };
147 if (is_valid_vbucket_state_t(s)) {
148 return vbucket_states[s];
149 } else {
150 return "Illegal vbucket state";
151 }
152 }
153
154 ENGINE_ERROR_CODE create_instance(uint64_t interface,
155 GET_SERVER_API get_server_api,
156 ENGINE_HANDLE **handle) {
157 SERVER_HANDLE_V1 *api = get_server_api();
158 if (interface != 1 || api == NULL) {
159 return ENGINE_ENOTSUP;
160 }
161
162 struct default_engine *engine = malloc(sizeof(*engine));
163 if (engine == NULL) {
164 return ENGINE_ENOMEM;
165 }
166
167 struct default_engine default_engine = {
168 .engine = {
169 .interface = {
170 .interface = 1
171 },
172 .get_info = default_get_info,
173 .initialize = default_initialize,
174 .destroy = default_destroy,
175 .allocate = default_item_allocate,
176 .remove = default_item_delete,
177 .release = default_item_release,
178 .get = default_get,
179 .get_stats = default_get_stats,
180 .reset_stats = default_reset_stats,
181 .store = default_store,
182 .arithmetic = default_arithmetic,
183 .flush = default_flush,
184 .unknown_command = default_unknown_command,
185 .tap_notify = default_tap_notify,
186 .get_tap_iterator = default_get_tap_iterator,
187 .item_set_cas = item_set_cas,
188 .get_item_info = get_item_info
189 },
190 .server = *api,
191 .get_server_api = get_server_api,
192 .initialized = true,
193 .assoc = {
194 .hashpower = 16,
195 },
196 .slabs = {
197 .lock = PTHREAD_MUTEX_INITIALIZER
198 },
199 .cache_lock = PTHREAD_MUTEX_INITIALIZER,
200 .stats = {
201 .lock = PTHREAD_MUTEX_INITIALIZER,
202 },
203 .config = {
204 .use_cas = true,
205 .verbose = 0,
206 .oldest_live = 0,
207 .evict_to_free = true,
208 .maxbytes = 64 * 1024 * 1024,
209 .preallocate = false,
210 .factor = 1.25,
211 .chunk_size = 48,
212 .item_size_max= 1024 * 1024,
213 },
214 .scrubber = {
215 .lock = PTHREAD_MUTEX_INITIALIZER,
216 },
217 .tap_connections = {
218 .lock = PTHREAD_MUTEX_INITIALIZER,
219 .size = 10,
220 },
221 .info.engine_info = {
222 .description = "Default engine v0.1",
223 .num_features = 1,
224 .features = {
225 [0].feature = ENGINE_FEATURE_LRU
226 }
227 }
228 };
229
230 *engine = default_engine;
231 engine->tap_connections.clients = calloc(default_engine.tap_connections.size, sizeof(void*));
232 if (engine->tap_connections.clients == NULL) {
233 free(engine);
234 return ENGINE_ENOMEM;
235 }
236 *handle = (ENGINE_HANDLE*)&engine->engine;
237 return ENGINE_SUCCESS;
238 }
239
240 static inline struct default_engine* get_handle(ENGINE_HANDLE* handle) {
241 return (struct default_engine*)handle;
242 }
243
244 static inline hash_item* get_real_item(item* item) {
245 return (hash_item*)item;
246 }
247
248 static const engine_info* default_get_info(ENGINE_HANDLE* handle) {
249 return &get_handle(handle)->info.engine_info;
250 }
251
252 static ENGINE_ERROR_CODE default_initialize(ENGINE_HANDLE* handle,
253 const char* config_str) {
254 struct default_engine* se = get_handle(handle);
255
256 ENGINE_ERROR_CODE ret = initalize_configuration(se, config_str);
257 if (ret != ENGINE_SUCCESS) {
258 return ret;
259 }
260
261 /* fixup feature_info */
262 if (se->config.use_cas) {
263 se->info.engine_info.features[se->info.engine_info.num_features++].feature = ENGINE_FEATURE_CAS;
264 }
265
266 ret = assoc_init(se);
267 if (ret != ENGINE_SUCCESS) {
268 return ret;
269 }
270
271 ret = slabs_init(se, se->config.maxbytes, se->config.factor,
272 se->config.preallocate);
273 if (ret != ENGINE_SUCCESS) {
274 return ret;
275 }
276
277 se->server.callback->register_callback(handle, ON_DISCONNECT, default_handle_disconnect, handle);
278
279 return ENGINE_SUCCESS;
280 }
281
282 static void default_destroy(ENGINE_HANDLE* handle, const bool force) {
283 (void) force;
284 struct default_engine* se = get_handle(handle);
285
286 if (se->initialized) {
287 pthread_mutex_destroy(&se->cache_lock);
288 pthread_mutex_destroy(&se->stats.lock);
289 pthread_mutex_destroy(&se->slabs.lock);
290 se->initialized = false;
291 free(se->tap_connections.clients);
292 free(se);
293 }
294 }
295
296 static ENGINE_ERROR_CODE default_item_allocate(ENGINE_HANDLE* handle,
297 const void* cookie,
298 item **item,
299 const void* key,
300 const size_t nkey,
301 const size_t nbytes,
302 const int flags,
303 const rel_time_t exptime) {
304 struct default_engine* engine = get_handle(handle);
305 size_t ntotal = sizeof(hash_item) + nkey + nbytes;
306 if (engine->config.use_cas) {
307 ntotal += sizeof(uint64_t);
308 }
309 unsigned int id = slabs_clsid(engine, ntotal);
310 if (id == 0) {
311 return ENGINE_E2BIG;
312 }
313
314 hash_item *it;
315 it = item_alloc(engine, key, nkey, flags, engine->server.core->realtime(exptime),
316 nbytes, cookie);
317
318 if (it != NULL) {
319 *item = it;
320 return ENGINE_SUCCESS;
321 } else {
322 return ENGINE_ENOMEM;
323 }
324 }
325
326 static ENGINE_ERROR_CODE default_item_delete(ENGINE_HANDLE* handle,
327 const void* cookie,
328 const void* key,
329 const size_t nkey,
330 uint64_t cas,
331 uint16_t vbucket)
332 {
333 struct default_engine* engine = get_handle(handle);
334 VBUCKET_GUARD(engine, vbucket);
335
336 hash_item *it = item_get(engine, key, nkey);
337 if (it == NULL) {
338 return ENGINE_KEY_ENOENT;
339 }
340
341 if (cas == 0 || cas == item_get_cas(it)) {
342 item_unlink(engine, it);
343 item_release(engine, it);
344 } else {
345 return ENGINE_KEY_EEXISTS;
346 }
347
348 return ENGINE_SUCCESS;
349 }
350
351 static void default_item_release(ENGINE_HANDLE* handle,
352 const void *cookie,
353 item* item) {
354 item_release(get_handle(handle), get_real_item(item));
355 }
356
357 static ENGINE_ERROR_CODE default_get(ENGINE_HANDLE* handle,
358 const void* cookie,
359 item** item,
360 const void* key,
361 const int nkey,
362 uint16_t vbucket) {
363 struct default_engine *engine = get_handle(handle);
364 VBUCKET_GUARD(engine, vbucket);
365
366 *item = item_get(engine, key, nkey);
367 if (*item != NULL) {
368 return ENGINE_SUCCESS;
369 } else {
370 return ENGINE_KEY_ENOENT;
371 }
372 }
373
374 static void stats_vbucket(struct default_engine *e,
375 ADD_STAT add_stat,
376 const void *cookie) {
377 for (int i = 0; i < NUM_VBUCKETS; i++) {
378 vbucket_state_t state = get_vbucket_state(e, i);
379 if (state != vbucket_state_dead) {
380 char buf[16];
381 snprintf(buf, sizeof(buf), "vb_%d", i);
382 const char * state_name = vbucket_state_name(state);
383 add_stat(buf, strlen(buf), state_name, strlen(state_name), cookie);
384 }
385 }
386 }
387
388 static ENGINE_ERROR_CODE default_get_stats(ENGINE_HANDLE* handle,
389 const void* cookie,
390 const char* stat_key,
391 int nkey,
392 ADD_STAT add_stat)
393 {
394 struct default_engine* engine = get_handle(handle);
395 ENGINE_ERROR_CODE ret = ENGINE_SUCCESS;
396
397 if (stat_key == NULL) {
398 char val[128];
399 int len;
400
401 pthread_mutex_lock(&engine->stats.lock);
402 len = sprintf(val, "%"PRIu64, (uint64_t)engine->stats.evictions);
403 add_stat("evictions", 9, val, len, cookie);
404 len = sprintf(val, "%"PRIu64, (uint64_t)engine->stats.curr_items);
405 add_stat("curr_items", 10, val, len, cookie);
406 len = sprintf(val, "%"PRIu64, (uint64_t)engine->stats.total_items);
407 add_stat("total_items", 11, val, len, cookie);
408 len = sprintf(val, "%"PRIu64, (uint64_t)engine->stats.curr_bytes);
409 add_stat("bytes", 5, val, len, cookie);
410 len = sprintf(val, "%"PRIu64, engine->stats.reclaimed);
411 add_stat("reclaimed", 9, val, len, cookie);
412 len = sprintf(val, "%"PRIu64, (uint64_t)engine->config.maxbytes);
413 add_stat("engine_maxbytes", 15, val, len, cookie);
414 pthread_mutex_unlock(&engine->stats.lock);
415 } else if (strncmp(stat_key, "slabs", 5) == 0) {
416 slabs_stats(engine, add_stat, cookie);
417 } else if (strncmp(stat_key, "items", 5) == 0) {
418 item_stats(engine, add_stat, cookie);
419 } else if (strncmp(stat_key, "sizes", 5) == 0) {
420 item_stats_sizes(engine, add_stat, cookie);
421 } else if (strncmp(stat_key, "vbucket", 7) == 0) {
422 stats_vbucket(engine, add_stat, cookie);
423 } else if (strncmp(stat_key, "scrub", 5) == 0) {
424 char val[128];
425 int len;
426
427 pthread_mutex_lock(&engine->scrubber.lock);
428 if (engine->scrubber.running) {
429 add_stat("scrubber:status", 15, "running", 7, cookie);
430 } else {
431 add_stat("scrubber:status", 15, "stopped", 7, cookie);
432 }
433
434 if (engine->scrubber.started != 0) {
435 if (engine->scrubber.stopped != 0) {
436 time_t diff = engine->scrubber.started - engine->scrubber.stopped;
437 len = sprintf(val, "%"PRIu64, (uint64_t)diff);
438 add_stat("scrubber:last_run", 17, val, len, cookie);
439 }
440
441 len = sprintf(val, "%"PRIu64, engine->scrubber.visited);
442 add_stat("scrubber:visited", 16, val, len, cookie);
443 len = sprintf(val, "%"PRIu64, engine->scrubber.cleaned);
444 add_stat("scrubber:cleaned", 16, val, len, cookie);
445 }
446 pthread_mutex_unlock(&engine->scrubber.lock);
447 } else {
448 ret = ENGINE_KEY_ENOENT;
449 }
450
451 return ret;
452 }
453
454 static ENGINE_ERROR_CODE default_store(ENGINE_HANDLE* handle,
455 const void *cookie,
456 item* item,
457 uint64_t *cas,
458 ENGINE_STORE_OPERATION operation,
459 uint16_t vbucket) {
460 struct default_engine *engine = get_handle(handle);
461 VBUCKET_GUARD(engine, vbucket);
462 return store_item(engine, get_real_item(item), cas, operation,
463 cookie);
464 }
465
466 static ENGINE_ERROR_CODE default_arithmetic(ENGINE_HANDLE* handle,
467 const void* cookie,
468 const void* key,
469 const int nkey,
470 const bool increment,
471 const bool create,
472 const uint64_t delta,
473 const uint64_t initial,
474 const rel_time_t exptime,
475 uint64_t *cas,
476 uint64_t *result,
477 uint16_t vbucket) {
478 struct default_engine *engine = get_handle(handle);
479 VBUCKET_GUARD(engine, vbucket);
480
481 return arithmetic(engine, cookie, key, nkey, increment,
482 create, delta, initial, engine->server.core->realtime(exptime), cas,
483 result);
484 }
485
486 static ENGINE_ERROR_CODE default_flush(ENGINE_HANDLE* handle,
487 const void* cookie, time_t when) {
488 item_flush_expired(get_handle(handle), when);
489
490 return ENGINE_SUCCESS;
491 }
492
493 static void default_reset_stats(ENGINE_HANDLE* handle, const void *cookie) {
494 struct default_engine *engine = get_handle(handle);
495 item_stats_reset(engine);
496
497 pthread_mutex_lock(&engine->stats.lock);
498 engine->stats.evictions = 0;
499 engine->stats.reclaimed = 0;
500 engine->stats.total_items = 0;
501 pthread_mutex_unlock(&engine->stats.lock);
502 }
503
504 static ENGINE_ERROR_CODE initalize_configuration(struct default_engine *se,
505 const char *cfg_str) {
506 ENGINE_ERROR_CODE ret = ENGINE_SUCCESS;
507
508 se->config.vb0 = true;
509
510 if (cfg_str != NULL) {
511 struct config_item items[] = {
512 { .key = "use_cas",
513 .datatype = DT_BOOL,
514 .value.dt_bool = &se->config.use_cas },
515 { .key = "verbose",
516 .datatype = DT_SIZE,
517 .value.dt_size = &se->config.verbose },
518 { .key = "eviction",
519 .datatype = DT_BOOL,
520 .value.dt_bool = &se->config.evict_to_free },
521 { .key = "cache_size",
522 .datatype = DT_SIZE,
523 .value.dt_size = &se->config.maxbytes },
524 { .key = "preallocate",
525 .datatype = DT_BOOL,
526 .value.dt_bool = &se->config.preallocate },
527 { .key = "factor",
528 .datatype = DT_FLOAT,
529 .value.dt_float = &se->config.factor },
530 { .key = "chunk_size",
531 .datatype = DT_SIZE,
532 .value.dt_size = &se->config.chunk_size },
533 { .key = "item_size_max",
534 .datatype = DT_SIZE,
535 .value.dt_size = &se->config.item_size_max },
536 { .key = "ignore_vbucket",
537 .datatype = DT_BOOL,
538 .value.dt_bool = &se->config.ignore_vbucket },
539 { .key = "vb0",
540 .datatype = DT_BOOL,
541 .value.dt_bool = &se->config.vb0 },
542 { .key = "config_file",
543 .datatype = DT_CONFIGFILE },
544 { .key = NULL}
545 };
546
547 ret = se->server.core->parse_config(cfg_str, items, stderr);
548 }
549
550 if (se->config.vb0) {
551 set_vbucket_state(se, 0, vbucket_state_active);
552 }
553
554 return ENGINE_SUCCESS;
555 }
556
557 static bool set_vbucket(struct default_engine *e,
558 const void* cookie,
559 protocol_binary_request_set_vbucket *req,
560 ADD_RESPONSE response) {
561 size_t bodylen = ntohl(req->message.header.request.bodylen)
562 - ntohs(req->message.header.request.keylen);
563 if (bodylen != sizeof(vbucket_state_t)) {
564 const char *msg = "Incorrect packet format";
565 return response(NULL, 0, NULL, 0, msg, strlen(msg),
566 PROTOCOL_BINARY_RAW_BYTES,
567 PROTOCOL_BINARY_RESPONSE_EINVAL, 0, cookie);
568 }
569 vbucket_state_t state;
570 memcpy(&state, &req->message.body.state, sizeof(state));
571 state = ntohl(state);
572
573 if (!is_valid_vbucket_state_t(state)) {
574 const char *msg = "Invalid vbucket state";
575 return response(NULL, 0, NULL, 0, msg, strlen(msg),
576 PROTOCOL_BINARY_RAW_BYTES,
577 PROTOCOL_BINARY_RESPONSE_EINVAL, 0, cookie);
578 }
579
580 set_vbucket_state(e, ntohs(req->message.header.request.vbucket), state);
581 return response(NULL, 0, NULL, 0, &state, sizeof(state),
582 PROTOCOL_BINARY_RAW_BYTES,
583 PROTOCOL_BINARY_RESPONSE_SUCCESS, 0, cookie);
584 }
585
586 static bool get_vbucket(struct default_engine *e,
587 const void* cookie,
588 protocol_binary_request_get_vbucket *req,
589 ADD_RESPONSE response) {
590 vbucket_state_t state;
591 state = get_vbucket_state(e, ntohs(req->message.header.request.vbucket));
592 state = ntohl(state);
593
594 return response(NULL, 0, NULL, 0, &state, sizeof(state),
595 PROTOCOL_BINARY_RAW_BYTES,
596 PROTOCOL_BINARY_RESPONSE_SUCCESS, 0, cookie);
597 }
598
599 static bool rm_vbucket(struct default_engine *e,
600 const void *cookie,
601 protocol_binary_request_header *req,
602 ADD_RESPONSE response) {
603 set_vbucket_state(e, ntohs(req->request.vbucket), vbucket_state_dead);
604 return response(NULL, 0, NULL, 0, NULL, 0, PROTOCOL_BINARY_RAW_BYTES,
605 PROTOCOL_BINARY_RESPONSE_SUCCESS, 0, cookie);
606 }
607
608 static bool scrub_cmd(struct default_engine *e,
609 const void *cookie,
610 protocol_binary_request_header *request,
611 ADD_RESPONSE response) {
612
613 protocol_binary_response_status res = PROTOCOL_BINARY_RESPONSE_SUCCESS;
614 if (!item_start_scrub(e)) {
615 res = PROTOCOL_BINARY_RESPONSE_EBUSY;
616 }
617
618 return response(NULL, 0, NULL, 0, NULL, 0, PROTOCOL_BINARY_RAW_BYTES,
619 res, 0, cookie);
620 }
621
622 static bool touch(struct default_engine *e, const void *cookie,
623 protocol_binary_request_header *request,
624 ADD_RESPONSE response) {
625 if (request->request.extlen != 4 || request->request.keylen == 0) {
626 return response(NULL, 0, NULL, 0, NULL, 0, PROTOCOL_BINARY_RAW_BYTES,
627 PROTOCOL_BINARY_RESPONSE_EINVAL, 0, cookie);
628 }
629
630 protocol_binary_request_touch *t = (void*)request;
631 void *key = t->bytes + sizeof(t->bytes);
632 uint32_t exptime = ntohl(t->message.body.expiration);
633 uint16_t nkey = ntohs(request->request.keylen);
634
635 hash_item *item = touch_item(e, key, nkey,
636 e->server.core->realtime(exptime));
637 if (item == NULL) {
638 if (request->request.opcode == PROTOCOL_BINARY_CMD_GATQ) {
639 return true;
640 } else {
641 return response(NULL, 0, NULL, 0, NULL, 0, PROTOCOL_BINARY_RAW_BYTES,
642 PROTOCOL_BINARY_RESPONSE_KEY_ENOENT, 0, cookie);
643 }
644 } else {
645 bool ret;
646 if (request->request.opcode == PROTOCOL_BINARY_CMD_TOUCH) {
647 ret = response(NULL, 0, NULL, 0, NULL, 0, PROTOCOL_BINARY_RAW_BYTES,
648 PROTOCOL_BINARY_RESPONSE_SUCCESS, 0, cookie);
649 } else {
650 ret = response(NULL, 0, &item->flags, sizeof(item->flags),
651 item_get_data(item), item->nbytes,
652 PROTOCOL_BINARY_RAW_BYTES,
653 PROTOCOL_BINARY_RESPONSE_SUCCESS,
654 item_get_cas(item), cookie);
655 }
656 item_release(e, item);
657 return ret;
658 }
659 }
660
661 static ENGINE_ERROR_CODE default_unknown_command(ENGINE_HANDLE* handle,
662 const void* cookie,
663 protocol_binary_request_header *request,
664 ADD_RESPONSE response)
665 {
666 struct default_engine* e = get_handle(handle);
667 bool sent;
668
669 switch(request->request.opcode) {
670 case PROTOCOL_BINARY_CMD_SCRUB:
671 sent = scrub_cmd(e, cookie, request, response);
672 break;
673 case PROTOCOL_BINARY_CMD_DEL_VBUCKET:
674 sent = rm_vbucket(e, cookie, request, response);
675 break;
676 case PROTOCOL_BINARY_CMD_SET_VBUCKET:
677 sent = set_vbucket(e, cookie, (void*)request, response);
678 break;
679 case PROTOCOL_BINARY_CMD_GET_VBUCKET:
680 sent = get_vbucket(e, cookie, (void*)request, response);
681 break;
682 case PROTOCOL_BINARY_CMD_TOUCH:
683 case PROTOCOL_BINARY_CMD_GAT:
684 case PROTOCOL_BINARY_CMD_GATQ:
685 sent = touch(e, cookie, request, response);
686 break;
687 default:
688 sent = response(NULL, 0, NULL, 0, NULL, 0, PROTOCOL_BINARY_RAW_BYTES,
689 PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND, 0, cookie);
690 break;
691 }
692
693 if (sent) {
694 return ENGINE_SUCCESS;
695 } else {
696 return ENGINE_FAILED;
697 }
698 }
699
700
701 uint64_t item_get_cas(const hash_item* item)
702 {
703 if (item->iflag & ITEM_WITH_CAS) {
704 return *(uint64_t*)(item + 1);
705 }
706 return 0;
707 }
708
709 void item_set_cas(ENGINE_HANDLE *handle, const void *cookie,
710 item* item, uint64_t val)
711 {
712 hash_item* it = get_real_item(item);
713 if (it->iflag & ITEM_WITH_CAS) {
714 *(uint64_t*)(it + 1) = val;
715 }
716 }
717
718 const void* item_get_key(const hash_item* item)
719 {
720 char *ret = (void*)(item + 1);
721 if (item->iflag & ITEM_WITH_CAS) {
722 ret += sizeof(uint64_t);
723 }
724
725 return ret;
726 }
727
728 char* item_get_data(const hash_item* item)
729 {
730 return ((char*)item_get_key(item)) + item->nkey;
731 }
732
733 uint8_t item_get_clsid(const hash_item* item)
734 {
735 return 0;
736 }
737
738 static bool get_item_info(ENGINE_HANDLE *handle, const void *cookie,
739 const item* item, item_info *item_info)
740 {
741 hash_item* it = (hash_item*)item;
742 if (item_info->nvalue < 1) {
743 return false;
744 }
745 item_info->cas = item_get_cas(it);
746 item_info->exptime = it->exptime;
747 item_info->nbytes = it->nbytes;
748 item_info->flags = it->flags;
749 item_info->clsid = it->slabs_clsid;
750 item_info->nkey = it->nkey;
751 item_info->nvalue = 1;
752 item_info->key = item_get_key(it);
753 item_info->value[0].iov_base = item_get_data(it);
754 item_info->value[0].iov_len = it->nbytes;
755 return true;
756 }
757
758 static ENGINE_ERROR_CODE default_tap_notify(ENGINE_HANDLE* handle,
759 const void *cookie,
760 void *engine_specific,
761 uint16_t nengine,
762 uint8_t ttl,
763 uint16_t tap_flags,
764 tap_event_t tap_event,
765 uint32_t tap_seqno,
766 const void *key,
767 size_t nkey,
768 uint32_t flags,
769 uint32_t exptime,
770 uint64_t cas,
771 const void *data,
772 size_t ndata,
773 uint16_t vbucket) {
774 struct default_engine* engine = get_handle(handle);
775 vbucket_state_t state;
776 item *it;
777 ENGINE_ERROR_CODE ret = ENGINE_SUCCESS;
778
779 switch (tap_event) {
780 case TAP_ACK:
781 /* We don't provide a tap stream, so we should never receive this */
782 abort();
783
784 case TAP_FLUSH:
785 return default_flush(handle, cookie, 0);
786
787 case TAP_DELETION:
788 return default_item_delete(handle, cookie, key, nkey, cas, vbucket);
789
790 case TAP_MUTATION:
791 it = engine->server.cookie->get_engine_specific(cookie);
792 if (it == NULL) {
793 ret = default_item_allocate(handle, cookie, &it, key, nkey, ndata, flags, exptime);
794 switch (ret) {
795 case ENGINE_SUCCESS:
796 break;
797 case ENGINE_ENOMEM:
798 return ENGINE_TMPFAIL;
799 default:
800 return ret;
801 }
802 }
803 memcpy(item_get_data(it), data, ndata);
804 engine->server.cookie->store_engine_specific(cookie, NULL);
805 item_set_cas(handle, cookie, it, cas);
806 ret = default_store(handle, cookie, it, &cas, OPERATION_SET, vbucket);
807 if (ret == ENGINE_EWOULDBLOCK) {
808 engine->server.cookie->store_engine_specific(cookie, it);
809 } else {
810 item_release(engine, it);
811 }
812
813 break;
814
815 case TAP_VBUCKET_SET:
816 if (nengine != sizeof(vbucket_state_t)) {
817 // illegal size of the vbucket set package...
818 return ENGINE_DISCONNECT;
819 }
820
821 memcpy(&state, engine_specific, nengine);
822 state = (vbucket_state_t)ntohl(state);
823
824 if (!is_valid_vbucket_state_t(state)) {
825 return ENGINE_DISCONNECT;
826 }
827
828 set_vbucket_state(engine, vbucket, state);
829 return ENGINE_SUCCESS;
830
831 case TAP_OPAQUE:
832 // not supported, ignore
833 default:
834 engine->server.log->get_logger()->log(EXTENSION_LOG_DEBUG, cookie,
835 "Ignoring unknown tap event: %x", tap_event);
836 }
837
838 return ret;
839 }
840
841 static TAP_ITERATOR default_get_tap_iterator(ENGINE_HANDLE* handle,
842 const void* cookie,
843 const void* client,
844 size_t nclient,
845 uint32_t flags,
846 const void* userdata,
847 size_t nuserdata) {
848 struct default_engine* engine = get_handle(handle);
849
850 if ((flags & TAP_CONNECT_FLAG_TAKEOVER_VBUCKETS)) { /* Not supported */
851 return NULL;
852 }
853
854 pthread_mutex_lock(&engine->tap_connections.lock);
855 int ii;
856 for (ii = 0; ii < engine->tap_connections.size; ++ii) {
857 if (engine->tap_connections.clients[ii] == NULL) {
858 engine->tap_connections.clients[ii] = cookie;
859 break;
860 }
861 }
862 pthread_mutex_unlock(&engine->tap_connections.lock);
863 if (ii == engine->tap_connections.size) {
864 // @todo allow more connections :)
865 return NULL;
866 }
867
868 if (!initialize_item_tap_walker(engine, cookie)) {
869 /* Failed to create */
870 pthread_mutex_lock(&engine->tap_connections.lock);
871 engine->tap_connections.clients[ii] = NULL;
872 pthread_mutex_unlock(&engine->tap_connections.lock);
873 return NULL;
874 }
875
876 return item_tap_walker;
877 }
878
879 static void default_handle_disconnect(const void *cookie,
880 ENGINE_EVENT_TYPE type,
881 const void *event_data,
882 const void *cb_data) {
883 struct default_engine *engine = (struct default_engine*)cb_data;
884 pthread_mutex_lock(&engine->tap_connections.lock);
885 int ii;
886 for (ii = 0; ii < engine->tap_connections.size; ++ii) {
887 if (engine->tap_connections.clients[ii] == cookie) {
888 free(engine->server.cookie->get_engine_specific(cookie));
889 break;
890 }
891 }
892 pthread_mutex_unlock(&engine->tap_connections.lock);
893 }