Archipelago » qemu

    qemu_aio_set_fd_handler(s->sock, nbd_reply_ready, nbd_restart_write,

                            nbd_have_request, NULL, s);

    rc = nbd_send_request(s->sock, request);

        ret = qemu_co_sendv(s->sock, iov, request->len, offset);

        if (ret != request->len) {

            errno = -EIO;

    }

    /* Failed to establish connection */

        logout("Failed to establish connection to NBD server\n");

        return -errno;

    }

    /* NBD handshake */

    ret = nbd_receive_negotiate(sock, s->export_name, &s->nbdflags, &size,

                                &blocksize);

        logout("Failed to negotiate with the NBD server\n");

        closesocket(sock);

        return -errno;

    BDRVNBDState *s = bs->opaque;

    struct nbd_request request;

    struct nbd_reply reply;

    request.type = NBD_CMD_READ;

    request.from = sector_num * 512;

    request.len = nb_sectors * 512;

    nbd_coroutine_start(s, &request);

        reply.error = errno;

    } else {

        nbd_co_receive_reply(s, &request, &reply, qiov->iov, offset);

    BDRVNBDState *s = bs->opaque;

    struct nbd_request request;

    struct nbd_reply reply;

    request.type = NBD_CMD_WRITE;

    if (!bdrv_enable_write_cache(bs) && (s->nbdflags & NBD_FLAG_SEND_FUA)) {

    request.len = nb_sectors * 512;

    nbd_coroutine_start(s, &request);

        reply.error = errno;

    } else {

        nbd_co_receive_reply(s, &request, &reply, NULL, 0);

    BDRVNBDState *s = bs->opaque;

    struct nbd_request request;

    struct nbd_reply reply;

    if (!(s->nbdflags & NBD_FLAG_SEND_FLUSH)) {

        return 0;

    request.len = 0;

    nbd_coroutine_start(s, &request);

        reply.error = errno;

    } else {

        nbd_co_receive_reply(s, &request, &reply, NULL, 0);

    BDRVNBDState *s = bs->opaque;

    struct nbd_request request;

    struct nbd_reply reply;

    if (!(s->nbdflags & NBD_FLAG_SEND_TRIM)) {

        return 0;

    request.len = nb_sectors * 512;

    nbd_coroutine_start(s, &request);

        reply.error = errno;

    } else {

        nbd_co_receive_reply(s, &request, &reply, NULL, 0);

            len = send(fd, buffer + offset, size - offset, 0);

        }

            errno = socket_error();

        }

        /* eof */

            break;

        }

        offset += len;

    }

{

    TRACE("Setting NBD socket");

        int serrno = errno;

        LOG("Failed to set NBD socket");

        errno = serrno;

    TRACE("Setting block size to %lu", (unsigned long)blocksize);

        int serrno = errno;

        LOG("Failed setting NBD block size");

        errno = serrno;

        TRACE("Setting size to %zd block(s)", (size_t)(size / blocksize));

        int serrno = errno;

        LOG("Failed setting size (in blocks)");

        errno = serrno;

    TRACE("Doing NBD loop");

    ret = ioctl(fd, NBD_DO_IT);

        /* NBD_DO_IT normally returns EPIPE when someone has disconnected

         * the socket via NBD_DISCONNECT.  We do not want to return 1 in

         * that case.

    if (!len) {

        rc = nbd_send_reply(csock, reply);

            rc = -errno;

        }

    } else {

        socket_set_cork(csock, 1);

        rc = nbd_send_reply(csock, reply);

            ret = qemu_co_send(csock, req->data, len);

            if (ret != len) {

                errno = EIO;

                rc = -1;

            }

        }

            rc = -errno;

        }

        socket_set_cork(csock, 0);

    ssize_t rc;

    client->recv_coroutine = qemu_coroutine_self();

        rc = -EIO;

        goto out;

    }

            }

        }

            goto out;

        break;

    case NBD_CMD_DISC:

        TRACE("Request type is DISCONNECT");

            LOG("flush failed");

            reply.error = -ret;

        }

            goto out;

        break;

    case NBD_CMD_TRIM:

        TRACE("Request type is TRIM");

            LOG("discard failed");

            reply.error = -ret;

        }

            goto out;

        break;

    default:

        LOG("invalid request type (%u) received", request.type);

    invalid_request:

        reply.error = -EINVAL;

    error_reply:

            goto out;

        break;

    }

                          void (*close)(NBDClient *))

{

    NBDClient *client;

        return NULL;

    }

    client = g_malloc0(sizeof(NBDClient));

     *     modprobe nbd max_part=63

     */

    nbd = open(device, O_RDWR);

        close(nbd);

    }

    return NULL;

    pthread_t show_parts_thread;

    sock = unix_socket_outgoing(sockpath);

        goto out;

    }

    ret = nbd_receive_negotiate(sock, NULL, &nbdflags,

                                &size, &blocksize);

        goto out;

    }

    fd = open(device, O_RDWR);

        /* Linux-only, we can use %m in printf.  */

        fprintf(stderr, "Failed to open %s: %m", device);

        goto out;

    }

    ret = nbd_init(fd, sock, nbdflags, size, blocksize);

        goto out;

    }

    int fd = accept(server_fd, (struct sockaddr *)&addr, &addr_len);

    nbd_started = true;

        nb_fds++;

    }

}

    if (disconnect) {

        fd = open(argv[optind], O_RDWR);

            err(EXIT_FAILURE, "Cannot open %s", argv[optind]);

        nbd_disconnect(fd);

        close(fd);

        pid_t pid;

        int ret;

            err(EXIT_FAILURE, "Error setting up communication pipe");

        }

            /* Temporarily redirect stderr to the parent's pipe...  */

            dup2(stderr_fd[1], STDERR_FILENO);

                err(EXIT_FAILURE, "Failed to daemonize");

            }

            while ((ret = read(stderr_fd[0], buf, 1024)) > 0) {

                errors = true;

                ret = qemu_write_full(STDERR_FILENO, buf, ret);

                    exit(EXIT_FAILURE);

                }

            }

                err(EXIT_FAILURE, "Cannot read from daemon");

            }

        fd = tcp_socket_incoming(bindto, port);

    }

        return 1;

    }