libcouchbase 0.0.1

data/ext/libcouchbase/plugins/io/iocp/iocp_timer.c

@@ -0,0 +1,79 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+*     Copyright 2013 Couchbase, Inc.
+*
+*   Licensed under the Apache License, Version 2.0 (the "License");
+*   you may not use this file except in compliance with the License.
+*   You may obtain a copy of the License at
+*
+*       http://www.apache.org/licenses/LICENSE-2.0
+*
+*   Unless required by applicable law or agreed to in writing, software
+*   distributed under the License is distributed on an "AS IS" BASIS,
+*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*   See the License for the specific language governing permissions and
+*   limitations under the License.
+*/
+
+/**
+* New-Style v1 plugin for Windows, Using IOCP
+* @author Mark Nunberg
+* @author Sergey Avseyev
+*/
+
+#include "iocp_iops.h"
+
+static int iocp_timer_cmp_asc(lcb_list_t *a, lcb_list_t *b)
+{
+    iocp_timer_t *aa, *bb;
+
+    aa = LCB_LIST_ITEM(a, iocp_timer_t, list);
+    bb = LCB_LIST_ITEM(b, iocp_timer_t, list);
+    if (aa->ms > bb->ms) {
+        return 1;
+    } else if (aa->ms < bb->ms) {
+        return -1;
+    } else {
+        return 0;
+    }
+}
+
+lcb_uint64_t iocp_tmq_next_timeout(lcb_list_t *list, lcb_uint64_t now)
+{
+    if (LCB_LIST_IS_EMPTY(list)) {
+        return INFINITE;
+
+    } else {
+        iocp_timer_t *tt;
+        tt = LCB_LIST_ITEM(list->next, iocp_timer_t, list);
+        return tt->ms > now ? tt->ms - now : 0;
+    }
+}
+
+iocp_timer_t *iocp_tmq_pop(lcb_list_t *list, lcb_uint64_t now)
+{
+    iocp_timer_t *tt;
+
+    if (LCB_LIST_IS_EMPTY(list)) {
+        return NULL;
+    }
+    tt = LCB_LIST_ITEM(list->next, iocp_timer_t, list);
+    if (tt->ms > now) {
+        return NULL;
+    }
+    lcb_list_delete(&tt->list);
+    return tt;
+}
+
+void iocp_tmq_add(lcb_list_t *list, iocp_timer_t *timer)
+{
+    IOCP_LOG(IOCP_TRACE, "Adding timer %p with ms %lu", timer, timer->ms);
+    lcb_list_add_sorted(list, &timer->list, iocp_timer_cmp_asc);
+}
+
+void iocp_tmq_del(lcb_list_t *list, iocp_timer_t *timer)
+{
+    lcb_list_delete(&timer->list);
+    IOCP_LOG(IOCP_TRACE, "Removing %p. Empty?=%d", timer, LCB_LIST_IS_EMPTY(list));
+    (void)list;
+}

data/ext/libcouchbase/plugins/io/iocp/iocp_util.c

@@ -0,0 +1,229 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+/**
+ * New-Style v2 plugin for Windows, Using IOCP.
+ * This file contains various utility functions used by the plugin
+ * @author Mark Nunberg
+ */
+
+#include "iocp_iops.h"
+#include <sys/types.h>
+#include <sys/timeb.h>
+#include <time.h>
+#include "config.h"
+#include <libcouchbase/plugins/io/wsaerr-inl.c>
+
+#if defined(__MINGW32__) && !defined(_ftime_s)
+#define _ftime_s _ftime /** Mingw doens't have the _s variant */
+#endif
+
+int iocp_w32err_2errno(DWORD error)
+{
+    return wsaerr_map_impl(error);
+}
+
+DWORD iocp_set_last_error(lcb_io_opt_t io, SOCKET sock)
+{
+    int werr = GetLastError();
+    io->v.v2.error = iocp_w32err_2errno(werr);
+    return werr;
+}
+
+lcb_uint32_t iocp_micros(void)
+{
+    return (lcb_uint32_t)(gethrtime() / 1000);
+}
+
+LPFN_CONNECTEX iocp_initialize_connectex(SOCKET sock)
+{
+    LPFN_CONNECTEX ret = NULL;
+    DWORD dwBytes;
+    GUID ce_guid = WSAID_CONNECTEX;
+
+    WSAIoctl(sock,
+             SIO_GET_EXTENSION_FUNCTION_POINTER,
+             &ce_guid,
+             sizeof(ce_guid),
+             &ret,
+             sizeof(&ret),
+             &dwBytes,
+             NULL,
+             NULL);
+
+    return ret;
+}
+
+int iocp_just_scheduled(iocp_t *io, iocp_overlapped_t *ol, int status)
+{
+    DWORD err = GetLastError();
+    IOCP_LOG(IOCP_TRACE, "Pending count: %d", io->n_iopending);
+    if ((status != 0 && err == WSA_IO_PENDING) || status == 0) {
+        io->n_iopending++;
+        ol->sd->refcount++;
+        return 0;
+    }
+
+    /**
+     * Otherwise, there's something wrong
+     */
+    IOCP_LOG(IOCP_ERR, "Got non-harmless error for %p: %d", ol, (int)err);
+    io->base.v.v2.error = iocp_w32err_2errno(err);
+    return -1;
+}
+
+void iocp_socket_decref(iocp_t *io, iocp_sockdata_t *sd)
+{
+    if (--sd->refcount) {
+        return;
+    }
+
+    if (sd->sSocket != INVALID_SOCKET) {
+        closesocket(sd->sSocket);
+    }
+
+    lcb_list_delete(&sd->list);
+
+    (void)io;
+    free(sd);
+}
+
+void iocp_on_dequeued(iocp_t *io, iocp_sockdata_t *sd, int action)
+{
+    IOCP_LOG(IOCP_TRACE, "Dequeing. A=%d, Pending=%d", action, io->n_iopending);
+    iocp_socket_decref(io, sd);
+}
+
+/**This following function was copied from libuv.
+ * See http://github.com/joyent/libuv for more details */
+int iocp_overlapped_status(OVERLAPPED *lpOverlapped)
+{
+    NTSTATUS status = (NTSTATUS)lpOverlapped->Internal;
+    switch (status) {
+    case 0:
+        return ERROR_SUCCESS;
+
+    case STATUS_PENDING:
+        return ERROR_IO_PENDING;
+
+    case STATUS_INVALID_HANDLE:
+    case STATUS_OBJECT_TYPE_MISMATCH:
+        return WSAENOTSOCK;
+
+    case STATUS_INSUFFICIENT_RESOURCES:
+    case STATUS_PAGEFILE_QUOTA:
+    case STATUS_COMMITMENT_LIMIT:
+    case STATUS_WORKING_SET_QUOTA:
+    case STATUS_NO_MEMORY:
+    case STATUS_CONFLICTING_ADDRESSES:
+    case STATUS_QUOTA_EXCEEDED:
+    case STATUS_TOO_MANY_PAGING_FILES:
+    case STATUS_REMOTE_RESOURCES:
+    case STATUS_TOO_MANY_ADDRESSES:
+        return WSAENOBUFS;
+
+    case STATUS_SHARING_VIOLATION:
+    case STATUS_ADDRESS_ALREADY_EXISTS:
+        return WSAEADDRINUSE;
+
+    case STATUS_LINK_TIMEOUT:
+    case STATUS_IO_TIMEOUT:
+    case STATUS_TIMEOUT:
+        return WSAETIMEDOUT;
+
+    case STATUS_GRACEFUL_DISCONNECT:
+        return WSAEDISCON;
+
+    case STATUS_REMOTE_DISCONNECT:
+    case STATUS_CONNECTION_RESET:
+    case STATUS_LINK_FAILED:
+    case STATUS_CONNECTION_DISCONNECTED:
+    case STATUS_PORT_UNREACHABLE:
+    case STATUS_HOPLIMIT_EXCEEDED:
+        return WSAECONNRESET;
+
+    case STATUS_LOCAL_DISCONNECT:
+    case STATUS_TRANSACTION_ABORTED:
+    case STATUS_CONNECTION_ABORTED:
+        return WSAECONNABORTED;
+
+    case STATUS_BAD_NETWORK_PATH:
+    case STATUS_NETWORK_UNREACHABLE:
+    case STATUS_PROTOCOL_UNREACHABLE:
+        return WSAENETUNREACH;
+
+    case STATUS_HOST_UNREACHABLE:
+        return WSAEHOSTUNREACH;
+
+    case STATUS_CANCELLED:
+    case STATUS_REQUEST_ABORTED:
+        return WSAEINTR;
+
+    case STATUS_BUFFER_OVERFLOW:
+    case STATUS_INVALID_BUFFER_SIZE:
+        return WSAEMSGSIZE;
+
+    case STATUS_BUFFER_TOO_SMALL:
+    case STATUS_ACCESS_VIOLATION:
+        return WSAEFAULT;
+
+    case STATUS_DEVICE_NOT_READY:
+    case STATUS_REQUEST_NOT_ACCEPTED:
+        return WSAEWOULDBLOCK;
+
+    case STATUS_INVALID_NETWORK_RESPONSE:
+    case STATUS_NETWORK_BUSY:
+    case STATUS_NO_SUCH_DEVICE:
+    case STATUS_NO_SUCH_FILE:
+    case STATUS_OBJECT_PATH_NOT_FOUND:
+    case STATUS_OBJECT_NAME_NOT_FOUND:
+    case STATUS_UNEXPECTED_NETWORK_ERROR:
+        return WSAENETDOWN;
+
+    case STATUS_INVALID_CONNECTION:
+        return WSAENOTCONN;
+
+    case STATUS_REMOTE_NOT_LISTENING:
+    case STATUS_CONNECTION_REFUSED:
+        return WSAECONNREFUSED;
+
+    case STATUS_PIPE_DISCONNECTED:
+        return WSAESHUTDOWN;
+
+    case STATUS_INVALID_ADDRESS:
+    case STATUS_INVALID_ADDRESS_COMPONENT:
+        return WSAEADDRNOTAVAIL;
+
+    case STATUS_NOT_SUPPORTED:
+    case STATUS_NOT_IMPLEMENTED:
+        return WSAEOPNOTSUPP;
+
+    case STATUS_ACCESS_DENIED:
+        return WSAEACCES;
+
+    default:
+        if ((status & (FACILITY_NTWIN32 << 16)) == (FACILITY_NTWIN32 << 16) &&
+                (status & (ERROR_SEVERITY_ERROR | ERROR_SEVERITY_WARNING))) {
+            /* It's a windows error that has been previously mapped to an */
+            /* ntstatus code. */
+            return (DWORD)(status & 0xffff);
+        } else {
+            /* The default fallback for unmappable ntstatus codes. */
+            return WSAEINVAL;
+        }
+    }
+}

data/ext/libcouchbase/plugins/io/libev/CMakeLists.txt

@@ -0,0 +1,29 @@
+INSTALL(
+    FILES
+    libev_io_opts.h
+    DESTINATION
+    include/libcouchbase)
+
+IF(NOT (HAVE_LIBEV3 OR HAVE_LIBEV4))
+    RETURN()
+ENDIF()
+
+
+ADD_LIBRARY(couchbase_libev SHARED plugin-libev.c)
+SET_TARGET_PROPERTIES(couchbase_libev
+    PROPERTIES
+    PREFIX "lib"
+    IMPORT_PREFIX "lib"
+    COMPILE_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_CORE_CFLAGS} -std=gnu99")
+TARGET_LINK_LIBRARIES(couchbase_libev ${LIBEV_LIBRARIES})
+INCLUDE_DIRECTORIES(AFTER ${LIBEV_INCLUDE_DIR})
+
+IF(HAVE_LIBEV4)
+    ADD_DEFINITIONS(-DHAVE_LIBEV4)
+ELSE()
+    ADD_DEFINITIONS(-DHAVE_LIBEV3)
+ENDIF()
+
+INSTALL(TARGETS
+    couchbase_libev
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})

data/ext/libcouchbase/plugins/io/libev/libev_io_opts.h

@@ -0,0 +1,65 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2011-2012 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+/**
+ * @file
+ * libev integration with libcouchbase
+ * @author Sergey Avseyev
+ */
+
+/**
+ * @ingroup lcb-io-plugin-api
+ * @defgroup lcb-libev libev
+ * @brief libev integration
+ *
+ * @details
+ * libcouchbase_create_libev_io_opts() allows you to create an instance
+ * of the ioopts that will utilize libev. You may either supply an event
+ * loop (if you'd like to add your own events into the loop), or it will
+ * create it's own.
+ *
+ * @addtogroup lcb-libev
+ * @{
+ */
+#ifndef LIBCOUCHBASE_LIBEV_IO_OPTS_H
+#define LIBCOUCHBASE_LIBEV_IO_OPTS_H 1
+
+#include <libcouchbase/couchbase.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /**
+     * Create an instance of an event handler that utilize libev for
+     * event notification.
+     *
+     * @param version the API version to use
+     * @param loop the event loop (struct ev_loop *) to hook use (please
+     *             note that you shouldn't reference the event loop from
+     *             multiple threads)
+     * @param io a pointer to a newly created and initialized event handler
+     * @return status of the operation
+     */
+    LIBCOUCHBASE_API
+    lcb_error_t lcb_create_libev_io_opts(int version, lcb_io_opt_t *io, void *loop);
+#ifdef __cplusplus
+}
+#endif
+
+/**@}*/
+#endif

data/ext/libcouchbase/plugins/io/libev/plugin-libev.c

@@ -0,0 +1,289 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+/**
+ * This file contains IO operations that use libev
+ *
+ * @author Sergey Avseyev
+ */
+#define LCB_IOPS_V12_NO_DEPRECATE
+#include "config.h"
+#ifdef HAVE_LIBEV_EV_H
+#include <libev/ev.h>
+#else
+#include <ev.h>
+#endif
+#include "libev_io_opts.h"
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <libcouchbase/plugins/io/bsdio-inl.c>
+
+struct libev_cookie {
+    struct ev_loop *loop;
+    int allocated;
+    int suspended;
+};
+
+
+struct libev_event {
+    union {
+        struct ev_io io;
+        struct ev_timer timer;
+    } ev;
+    void *data;
+    void (*handler)(lcb_socket_t sock, short which, void *cb_data);
+};
+
+static void handler_thunk(struct ev_loop *loop, ev_io *io, int events)
+{
+    struct libev_event *evt = (struct libev_event *)io;
+    int which = 0;
+
+    if (events & EV_READ) {
+        which |= LCB_READ_EVENT;
+    }
+    if (events & EV_WRITE) {
+        which |= LCB_WRITE_EVENT;
+    }
+    evt->handler(io->fd, which, evt->data);
+
+    (void)loop;
+}
+
+
+static void timer_thunk(struct ev_loop *loop, ev_timer *timer, int events)
+{
+    struct libev_event *evt = (struct libev_event *)timer;
+    evt->handler(0, 0, evt->data);
+    (void)events;
+    (void)loop;
+
+}
+
+static void *lcb_io_create_event(struct lcb_io_opt_st *iops)
+{
+    struct libev_event *event = calloc(1, sizeof(*event));
+    (void)iops;
+    return event;
+}
+
+static int lcb_io_update_event(struct lcb_io_opt_st *iops,
+                               lcb_socket_t sock,
+                               void *event,
+                               short flags,
+                               void *cb_data,
+                               void (*handler)(lcb_socket_t sock,
+                                               short which,
+                                               void *cb_data))
+{
+    struct libev_cookie *io_cookie = iops->v.v2.cookie;
+    struct libev_event *evt = event;
+    int events = EV_NONE;
+
+    if (flags & LCB_READ_EVENT) {
+        events |= EV_READ;
+    }
+    if (flags & LCB_WRITE_EVENT) {
+        events |= EV_WRITE;
+    }
+
+    if (events == evt->ev.io.events && handler == evt->handler) {
+        /* no change! */
+        return 0;
+    }
+
+    ev_io_stop(io_cookie->loop, &evt->ev.io);
+    evt->data = cb_data;
+    evt->handler = handler;
+    ev_init(&evt->ev.io, handler_thunk);
+    ev_io_set(&evt->ev.io, sock, events);
+    ev_io_stop(io_cookie->loop, &evt->ev.io);
+    ev_io_start(io_cookie->loop, &evt->ev.io);
+
+    return 0;
+}
+static void lcb_io_delete_event(struct lcb_io_opt_st *iops,
+                                lcb_socket_t sock,
+                                void *event)
+{
+    struct libev_cookie *io_cookie = iops->v.v2.cookie;
+    struct libev_event *evt = event;
+    ev_io_stop(io_cookie->loop, &evt->ev.io);
+    ev_io_init(&evt->ev.io, NULL, 0, 0);
+    (void)sock;
+}
+
+static void lcb_io_destroy_event(struct lcb_io_opt_st *iops,
+                                 void *event)
+{
+    lcb_io_delete_event(iops, -1, event);
+    free(event);
+}
+
+static int lcb_io_update_timer(struct lcb_io_opt_st *iops,
+                               void *timer,
+                               lcb_uint32_t usec,
+                               void *cb_data,
+                               void (*handler)(lcb_socket_t sock,
+                                               short which,
+                                               void *cb_data))
+{
+    struct libev_cookie *io_cookie = iops->v.v2.cookie;
+    struct libev_event *evt = timer;
+    ev_tstamp start;
+    evt->data = cb_data;
+    evt->handler = handler;
+    start = usec / (ev_tstamp)1000000;
+    ev_timer_stop(io_cookie->loop, &evt->ev.timer);
+    ev_timer_init(&evt->ev.timer, timer_thunk, start, 0);
+    ev_timer_start(io_cookie->loop, &evt->ev.timer);
+    return 0;
+}
+
+static void lcb_io_delete_timer(struct lcb_io_opt_st *iops,
+                                void *event)
+{
+    struct libev_cookie *io_cookie = iops->v.v2.cookie;
+    struct libev_event *evt = event;
+    ev_timer_stop(io_cookie->loop, &evt->ev.timer);
+}
+
+static void lcb_io_destroy_timer(struct lcb_io_opt_st *iops,
+                                 void *event)
+{
+    lcb_io_delete_timer(iops, event);
+    free(event);
+}
+
+static void lcb_io_stop_event_loop(struct lcb_io_opt_st *iops)
+{
+    struct libev_cookie *io_cookie = iops->v.v2.cookie;
+#ifdef HAVE_LIBEV4
+    ev_break(io_cookie->loop, EVBREAK_ONE);
+#else
+    ev_unloop(io_cookie->loop, EVUNLOOP_ONE);
+#endif
+}
+
+static void run_common(struct lcb_io_opt_st *iops, int is_tick)
+{
+    struct libev_cookie *io_cookie = iops->v.v2.cookie;
+    int flags;
+
+    io_cookie->suspended = 0;
+#ifdef HAVE_LIBEV4
+    flags = is_tick ? EVRUN_NOWAIT : 0;
+    ev_run(io_cookie->loop, flags);
+#else
+    flags = is_tick ? EVLOOP_NOBLOCK : 0;
+    ev_loop(io_cookie->loop, flags);
+#endif
+    io_cookie->suspended = 1;
+
+}
+
+static void lcb_io_run_event_loop(struct lcb_io_opt_st *iops)
+{
+    run_common(iops, 0);
+}
+
+static void lcb_io_tick_event_loop(struct lcb_io_opt_st *iops)
+{
+    run_common(iops, 1);
+}
+
+static void lcb_destroy_io_opts(struct lcb_io_opt_st *iops)
+{
+    struct libev_cookie *io_cookie = iops->v.v2.cookie;
+    if (io_cookie->allocated) {
+        ev_loop_destroy(io_cookie->loop);
+    }
+    free(io_cookie);
+    free(iops);
+}
+
+static void
+procs2_ev_callback(int version, lcb_loop_procs *loop_procs,
+    lcb_timer_procs *timer_procs, lcb_bsd_procs *bsd_procs,
+    lcb_ev_procs *ev_procs, lcb_completion_procs *completion_procs,
+    lcb_iomodel_t *iomodel)
+{
+    ev_procs->cancel = lcb_io_delete_event;
+    ev_procs->create = lcb_io_create_event;
+    ev_procs->watch = lcb_io_update_event;
+    ev_procs->destroy = lcb_io_destroy_event;
+
+    timer_procs->create = lcb_io_create_event;
+    timer_procs->cancel = lcb_io_delete_timer;
+    timer_procs->schedule = lcb_io_update_timer;
+    timer_procs->destroy = lcb_io_destroy_timer;
+
+    loop_procs->start = lcb_io_run_event_loop;
+    loop_procs->stop = lcb_io_stop_event_loop;
+    loop_procs->tick = lcb_io_tick_event_loop;
+
+    *iomodel = LCB_IOMODEL_EVENT;
+    wire_lcb_bsd_impl2(bsd_procs, version);
+}
+
+LIBCOUCHBASE_API
+lcb_error_t lcb_create_libev_io_opts(int version, lcb_io_opt_t *io, void *arg)
+{
+    struct ev_loop *loop = arg;
+    struct lcb_io_opt_st *ret;
+    struct libev_cookie *cookie;
+    if (version != 0) {
+        return LCB_PLUGIN_VERSION_MISMATCH;
+    }
+    ret = calloc(1, sizeof(*ret));
+    cookie = calloc(1, sizeof(*cookie));
+    if (ret == NULL || cookie == NULL) {
+        free(ret);
+        free(cookie);
+        return LCB_CLIENT_ENOMEM;
+    }
+
+    /* setup io iops! */
+    ret->version = 3;
+    ret->dlhandle = NULL;
+    ret->destructor = lcb_destroy_io_opts;
+    ret->v.v3.get_procs = procs2_ev_callback;
+
+    /* consider that struct isn't allocated by the library,
+     * `need_cleanup' flag might be set in lcb_create() */
+    ret->v.v3.need_cleanup = 0;
+
+    if (loop == NULL) {
+        if ((cookie->loop = ev_loop_new(EVFLAG_AUTO | EVFLAG_NOENV)) == NULL) {
+            free(ret);
+            free(cookie);
+            return LCB_CLIENT_ENOMEM;
+        }
+        cookie->allocated = 1;
+    } else {
+        cookie->loop = loop;
+        cookie->allocated = 0;
+    }
+    cookie->suspended = 1;
+    ret->v.v3.cookie = cookie;
+
+    wire_lcb_bsd_impl(ret);
+
+    *io = ret;
+    return LCB_SUCCESS;
+}