backend
return backend;
if (!backend)
backend = 0;
if (!backend && (flags & EVBACKEND_IOCP )) backend = iocp_init (EV_A_ flags);
if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);
if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);
if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);
if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
if (backend == EVBACKEND_IOCP ) iocp_destroy (EV_A);
if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);
if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A);
if (backend == EVBACKEND_POLL ) poll_destroy (EV_A);
if (backend == EVBACKEND_SELECT) select_destroy (EV_A);
backend = 0;
if (backend == EVBACKEND_PORT ) port_fork (EV_A);
if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);
if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
VARx(int, backend)
#define backend ((loop)->backend)
static struct hwt_backend backend = {
error = hwt_backend_register(&backend);
hwt_backend_unregister(&backend);
hwt_backend_unregister(&backend);
static struct hwt_backend backend = {
return (hwt_backend_register(&backend));
retval = lun->backend->config_read((union ctl_io *)ctnio);
retval = lun->backend->config_write((union ctl_io *)ctnio);
retval = lun->backend->data_submit((union ctl_io *)ctnio);
retval = lun->backend->config_write((union ctl_io *)ctnio);
retval = lun->backend->data_submit((union ctl_io *)ctnio);
retval = lun->backend->config_write((union ctl_io *)ctnio);
retval = lun->backend->config_write((union ctl_io *)ctnio);
retval = lun->backend->data_submit((union ctl_io *)ctnio);
lun->backend->lun_attr == NULL)
val = lun->backend->lun_attr(lun->be_lun, attr);
lun->backend->ioctl(NULL, CTL_LUN_REQ, (caddr_t)&ireq, 0,
struct ctl_backend_driver *backend;
backend = ctl_backend_find(lun_req->backend);
if (backend == NULL) {
lun_req->backend);
retval = backend->ioctl(dev, cmd, addr, flag, td);
(lun->backend == NULL) ? "none" :
lun->backend->name);
if (lun->backend == NULL) {
if (lun->backend->lun_info != NULL) {
retval = lun->backend->lun_info(lun->be_lun, sb);
struct ctl_backend_driver *backend;
STAILQ_FOREACH(backend, &softc->be_list, links) {
if (backend->type == type) {
retval = backend->ioctl(dev, cmd, addr, flag, td);
lun->backend->lun_attr == NULL)
lun->backend = be_lun->be;
retval = lun->backend->config_write((union ctl_io *)ctsio);
retval = lun->backend->config_write((union ctl_io *)ctsio);
retval = lun->backend->config_write((union ctl_io *)ctsio);
retval = lun->backend->config_write((union ctl_io *)ctsio);
retval = lun->backend->config_write((union ctl_io *)ctsio);
retval = lun->backend->config_write((union ctl_io *)ctsio);
if (lun->backend->lun_attr != NULL &&
(val = lun->backend->lun_attr(lun->be_lun, "blocksavail"))
if (lun->backend->lun_attr != NULL &&
(val = lun->backend->lun_attr(lun->be_lun, "blocksused"))
if (lun->backend->lun_attr != NULL &&
(val = lun->backend->lun_attr(lun->be_lun, "poolblocksavail"))
if (lun->backend->lun_attr != NULL &&
(val = lun->backend->lun_attr(lun->be_lun, "poolblocksused"))
retval = lun->backend->config_read((union ctl_io *)ctsio);
retval = lun->backend->data_submit((union ctl_io *)ctsio);
retval = lun->backend->data_submit((union ctl_io *)ctsio);
retval = lun->backend->data_submit((union ctl_io *)ctsio);
retval = lun->backend->data_submit((union ctl_io *)ctsio);
union ctl_be_block_bedata backend;
file_data = &be_lun->backend.file;
if (be_lun->backend.file.cred != NULL) {
crfree(be_lun->backend.file.cred);
be_lun->backend.file.cred = NULL;
file_data = &be_lun->backend.file;
file_data = &be_lun->backend.file;
char backend[CTL_BE_NAME_LEN];
char backend[CTL_BE_NAME_LEN]; /* passed to kernel*/
struct ctl_backend_driver *backend;
struct hwt_backend *backend;
backend = entry->backend;
if (strcmp(backend->name, name) == 0) {
return (backend);
hwt_backend_register(struct hwt_backend *backend)
if (backend == NULL ||
backend->name == NULL ||
backend->ops == NULL)
entry->backend = backend;
hwt_backend_unregister(struct hwt_backend *backend)
if (backend == NULL)
if (entry->backend == backend) {
if (thr->backend->ops->hwt_backend_thread_free == NULL)
thr->backend->ops->hwt_backend_thread_free(thr);
struct hwt_backend *backend;
thr->backend = ctx->hwt_backend;
struct hwt_backend *backend, struct hwt_alloc *halloc)
ctx->hwt_backend = backend;
thr->backend = ctx->hwt_backend;
struct hwt_backend *backend, struct hwt_alloc *halloc)
ctx->hwt_backend = backend;
struct hwt_backend *backend;
backend = hwt_backend_lookup(backend_name);
if (backend == NULL)
error = hwt_ioctl_alloc_mode_thread(td, ho, backend, halloc);
error = hwt_ioctl_alloc_mode_cpu(td, ho, backend, halloc);
struct hwt_backend *backend;
dev_data = &xbb->backend.dev;
file_data = &xbb->backend.file;
if (xbb->backend.dev.csw) {
dev_relthread(xbb->backend.dev.cdev,
xbb->backend.dev.dev_ref);
xbb->backend.dev.csw = NULL;
xbb->backend.dev.cdev = NULL;
if (xbb->backend.file.cred != NULL) {
crfree(xbb->backend.file.cred);
xbb->backend.file.cred = NULL;
xbb->backend.dev.cdev = xbb->vn->v_rdev;
xbb->backend.dev.csw = dev_refthread(xbb->backend.dev.cdev,
&xbb->backend.dev.dev_ref);
if (xbb->backend.dev.csw == NULL)
file_data = &xbb->backend.file;
union xbb_backend_data backend;
const char *backend, *name;
backend = get_config_value(node_name);
if (backend != NULL &&
uart_ns16550_tty_open(sc->uart_softc, backend) != 0) {
"for LPC device %s", backend, name);
char *backend, *cp;
backend = strndup(opts, cp - opts);
set_config_value_node(nvl, "backend", backend);
free(backend);
else if (uart_rxfifo_numchars(sc->backend) > 0 &&
uart_rxfifo_reset(sc->backend, 1);
uart_softc_lock(sc->backend);
uart_rxfifo_drain(sc->backend, loopback);
uart_softc_unlock(sc->backend);
uart_softc_lock(sc->backend);
if (uart_rxfifo_putchar(sc->backend, value,
uart_rxfifo_size(sc->backend) : 1;
uart_rxfifo_reset(sc->backend, fifosz);
uart_rxfifo_reset(sc->backend,
uart_rxfifo_size(sc->backend));
uart_softc_unlock(sc->backend);
uart_softc_lock(sc->backend);
reg = uart_rxfifo_getchar(sc->backend);
if (uart_rxfifo_numchars(sc->backend) > 0)
uart_softc_unlock(sc->backend);
sc->backend = uart_init();
return (uart_tty_open(sc->backend, device, uart_drain, sc));
ret = uart_rxfifo_snapshot(sc->backend, meta);
struct uart_softc *backend;
struct uart_softc *backend;
uart_rxfifo_reset(sc->backend, 1);
uart_softc_lock(sc->backend);
old_size = uart_rxfifo_numchars(sc->backend);
uart_rxfifo_drain(sc->backend, loopback);
uart_rxfifo_numchars(sc->backend) >= trig_lvl)
if (uart_rxfifo_numchars(sc->backend) > 0)
uart_softc_unlock(sc->backend);
uart_softc_lock(sc->backend);
if (uart_rxfifo_putchar(sc->backend, value & 0xff, loopback))
uart_rxfifo_reset(sc->backend, UART_FIFO_SIZE);
uart_rxfifo_reset(sc->backend, 1);
uart_softc_unlock(sc->backend);
uart_softc_lock(sc->backend);
reg = uart_rxfifo_getchar(sc->backend);
fifo_sz = uart_rxfifo_numchars(sc->backend);
fifo_sz = uart_rxfifo_numchars(sc->backend);
uart_softc_unlock(sc->backend);
sc->backend = uart_init();
return (uart_tty_open(sc->backend, device, uart_drain, sc));
strlcpy(req.backend, backend_name, sizeof(req.backend));
fprintf(stdout, "backend: %s\n", req.backend);
strlcpy(req.backend, backend_name, sizeof(req.backend));
strlcpy(req.backend, backend_name, sizeof(req.backend));
char *backend = NULL;
backend = strdup(optarg);
if ((backend != NULL)
&& (strcmp(lun->backend_type, backend) != 0))
strlcpy(req.backend, l_backend.c_str(), sizeof(req.backend));
strlcpy(req.backend, l_backend.c_str(), sizeof(req.backend));
strlcpy(req.backend, l_backend.c_str(), sizeof(req.backend));
struct voss_backend *backend;
if ((backend = dlsym(hdl, bsym)) == NULL) {
return (backend);