[qemu.git] / qemu-file.c

#include "qemu-common.h"
#include "qemu/iov.h"
#include "qemu/sockets.h"
#include "block/coroutine.h"
#include "migration/migration.h"
#include "migration/qemu-file.h"
#include "trace.h"

#define IO_BUF_SIZE 32768
#define MAX_IOV_SIZE MIN(IOV_MAX, 64)

struct QEMUFile {
    const QEMUFileOps *ops;
    void *opaque;

    int64_t bytes_xfer;
    int64_t xfer_limit;

    int64_t pos; /* start of buffer when writing, end of buffer
                    when reading */
    int buf_index;
    int buf_size; /* 0 when writing */
    uint8_t buf[IO_BUF_SIZE];

    struct iovec iov[MAX_IOV_SIZE];
    unsigned int iovcnt;

    int last_error;
};

typedef struct QEMUFileStdio {
    FILE *stdio_file;
    QEMUFile *file;
} QEMUFileStdio;

typedef struct QEMUFileSocket {
    int fd;
    QEMUFile *file;
} QEMUFileSocket;

static ssize_t socket_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
                                    int64_t pos)
{
    QEMUFileSocket *s = opaque;
    ssize_t len;
    ssize_t size = iov_size(iov, iovcnt);

    len = iov_send(s->fd, iov, iovcnt, 0, size);
    if (len < size) {
        len = -socket_error();
    }
    return len;
}

static int socket_get_fd(void *opaque)
{
    QEMUFileSocket *s = opaque;

    return s->fd;
}

static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
{
    QEMUFileSocket *s = opaque;
    ssize_t len;

    for (;;) {
        len = qemu_recv(s->fd, buf, size, 0);
        if (len != -1) {
            break;
        }
        if (socket_error() == EAGAIN) {
            yield_until_fd_readable(s->fd);
        } else if (socket_error() != EINTR) {
            break;
        }
    }

    if (len == -1) {
        len = -socket_error();
    }
    return len;
}

static int socket_close(void *opaque)
{
    QEMUFileSocket *s = opaque;
    closesocket(s->fd);
    g_free(s);
    return 0;
}

static int stdio_get_fd(void *opaque)
{
    QEMUFileStdio *s = opaque;

    return fileno(s->stdio_file);
}

static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos,
                            int size)
{
    QEMUFileStdio *s = opaque;
    int res;

    res = fwrite(buf, 1, size, s->stdio_file);

    if (res != size) {
        return -errno;
    }
    return res;
}

static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
{
    QEMUFileStdio *s = opaque;
    FILE *fp = s->stdio_file;
    int bytes;

    for (;;) {
        clearerr(fp);
        bytes = fread(buf, 1, size, fp);
        if (bytes != 0 || !ferror(fp)) {
            break;
        }
        if (errno == EAGAIN) {
            yield_until_fd_readable(fileno(fp));
        } else if (errno != EINTR) {
            break;
        }
    }
    return bytes;
}

static int stdio_pclose(void *opaque)
{
    QEMUFileStdio *s = opaque;
    int ret;
    ret = pclose(s->stdio_file);
    if (ret == -1) {
        ret = -errno;
    } else if (!WIFEXITED(ret) || WEXITSTATUS(ret) != 0) {
        /* close succeeded, but non-zero exit code: */
        ret = -EIO; /* fake errno value */
    }
    g_free(s);
    return ret;
}

static int stdio_fclose(void *opaque)
{
    QEMUFileStdio *s = opaque;
    int ret = 0;

    if (s->file->ops->put_buffer || s->file->ops->writev_buffer) {
        int fd = fileno(s->stdio_file);
        struct stat st;

        ret = fstat(fd, &st);
        if (ret == 0 && S_ISREG(st.st_mode)) {
            /*
             * If the file handle is a regular file make sure the
             * data is flushed to disk before signaling success.
             */
            ret = fsync(fd);
            if (ret != 0) {
                ret = -errno;
                return ret;
            }
        }
    }
    if (fclose(s->stdio_file) == EOF) {
        ret = -errno;
    }
    g_free(s);
    return ret;
}

static const QEMUFileOps stdio_pipe_read_ops = {
    .get_fd =     stdio_get_fd,
    .get_buffer = stdio_get_buffer,
    .close =      stdio_pclose
};

static const QEMUFileOps stdio_pipe_write_ops = {
    .get_fd =     stdio_get_fd,
    .put_buffer = stdio_put_buffer,
    .close =      stdio_pclose
};

QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
{
    FILE *stdio_file;
    QEMUFileStdio *s;

    if (mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
        fprintf(stderr, "qemu_popen: Argument validity check failed\n");
        return NULL;
    }

    stdio_file = popen(command, mode);
    if (stdio_file == NULL) {
        return NULL;
    }

    s = g_malloc0(sizeof(QEMUFileStdio));

    s->stdio_file = stdio_file;

    if (mode[0] == 'r') {
        s->file = qemu_fopen_ops(s, &stdio_pipe_read_ops);
    } else {
        s->file = qemu_fopen_ops(s, &stdio_pipe_write_ops);
    }
    return s->file;
}

static const QEMUFileOps stdio_file_read_ops = {
    .get_fd =     stdio_get_fd,
    .get_buffer = stdio_get_buffer,
    .close =      stdio_fclose
};

static const QEMUFileOps stdio_file_write_ops = {
    .get_fd =     stdio_get_fd,
    .put_buffer = stdio_put_buffer,
    .close =      stdio_fclose
};

static ssize_t unix_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
                                  int64_t pos)
{
    QEMUFileSocket *s = opaque;
    ssize_t len, offset;
    ssize_t size = iov_size(iov, iovcnt);
    ssize_t total = 0;

    assert(iovcnt > 0);
    offset = 0;
    while (size > 0) {
        /* Find the next start position; skip all full-sized vector elements  */
        while (offset >= iov[0].iov_len) {
            offset -= iov[0].iov_len;
            iov++, iovcnt--;
        }

        /* skip `offset' bytes from the (now) first element, undo it on exit */
        assert(iovcnt > 0);
        iov[0].iov_base += offset;
        iov[0].iov_len -= offset;

        do {
            len = writev(s->fd, iov, iovcnt);
        } while (len == -1 && errno == EINTR);
        if (len == -1) {
            return -errno;
        }

        /* Undo the changes above */
        iov[0].iov_base -= offset;
        iov[0].iov_len += offset;

        /* Prepare for the next iteration */
        offset += len;
        total += len;
        size -= len;
    }

    return total;
}

static int unix_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
{
    QEMUFileSocket *s = opaque;
    ssize_t len;

    for (;;) {
        len = read(s->fd, buf, size);
        if (len != -1) {
            break;
        }
        if (errno == EAGAIN) {
            yield_until_fd_readable(s->fd);
        } else if (errno != EINTR) {
            break;
        }
    }

    if (len == -1) {
        len = -errno;
    }
    return len;
}

static int unix_close(void *opaque)
{
    QEMUFileSocket *s = opaque;
    close(s->fd);
    g_free(s);
    return 0;
}

static const QEMUFileOps unix_read_ops = {
    .get_fd =     socket_get_fd,
    .get_buffer = unix_get_buffer,
    .close =      unix_close
};

static const QEMUFileOps unix_write_ops = {
    .get_fd =     socket_get_fd,
    .writev_buffer = unix_writev_buffer,
    .close =      unix_close
};

QEMUFile *qemu_fdopen(int fd, const char *mode)
{
    QEMUFileSocket *s;

    if (mode == NULL ||
        (mode[0] != 'r' && mode[0] != 'w') ||
        mode[1] != 'b' || mode[2] != 0) {
        fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
        return NULL;
    }

    s = g_malloc0(sizeof(QEMUFileSocket));
    s->fd = fd;

    if (mode[0] == 'r') {
        s->file = qemu_fopen_ops(s, &unix_read_ops);
    } else {
        s->file = qemu_fopen_ops(s, &unix_write_ops);
    }
    return s->file;
}

static const QEMUFileOps socket_read_ops = {
    .get_fd =     socket_get_fd,
    .get_buffer = socket_get_buffer,
    .close =      socket_close
};

static const QEMUFileOps socket_write_ops = {
    .get_fd =     socket_get_fd,
    .writev_buffer = socket_writev_buffer,
    .close =      socket_close
};

bool qemu_file_mode_is_not_valid(const char *mode)
{
    if (mode == NULL ||
        (mode[0] != 'r' && mode[0] != 'w') ||
        mode[1] != 'b' || mode[2] != 0) {
        fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
        return true;
    }

    return false;
}

QEMUFile *qemu_fopen_socket(int fd, const char *mode)
{
    QEMUFileSocket *s;

    if (qemu_file_mode_is_not_valid(mode)) {
        return NULL;
    }

    s = g_malloc0(sizeof(QEMUFileSocket));
    s->fd = fd;
    if (mode[0] == 'w') {
        qemu_set_block(s->fd);
        s->file = qemu_fopen_ops(s, &socket_write_ops);
    } else {
        s->file = qemu_fopen_ops(s, &socket_read_ops);
    }
    return s->file;
}

QEMUFile *qemu_fopen(const char *filename, const char *mode)
{
    QEMUFileStdio *s;

    if (qemu_file_mode_is_not_valid(mode)) {
        return NULL;
    }

    s = g_malloc0(sizeof(QEMUFileStdio));

    s->stdio_file = fopen(filename, mode);
    if (!s->stdio_file) {
        goto fail;
    }

    if (mode[0] == 'w') {
        s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
    } else {
        s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
    }
    return s->file;
fail:
    g_free(s);
    return NULL;
}

QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
{
    QEMUFile *f;

    f = g_malloc0(sizeof(QEMUFile));

    f->opaque = opaque;
    f->ops = ops;
    return f;
}

/*
 * Get last error for stream f
 *
 * Return negative error value if there has been an error on previous
 * operations, return 0 if no error happened.
 *
 */
int qemu_file_get_error(QEMUFile *f)
{
    return f->last_error;
}

void qemu_file_set_error(QEMUFile *f, int ret)
{
    if (f->last_error == 0) {
        f->last_error = ret;
    }
}

static inline bool qemu_file_is_writable(QEMUFile *f)
{
    return f->ops->writev_buffer || f->ops->put_buffer;
}

/**
 * Flushes QEMUFile buffer
 *
 * If there is writev_buffer QEMUFileOps it uses it otherwise uses
 * put_buffer ops.
 */
void qemu_fflush(QEMUFile *f)
{
    ssize_t ret = 0;

    if (!qemu_file_is_writable(f)) {
        return;
    }

    if (f->ops->writev_buffer) {
        if (f->iovcnt > 0) {
            ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos);
        }
    } else {
        if (f->buf_index > 0) {
            ret = f->ops->put_buffer(f->opaque, f->buf, f->pos, f->buf_index);
        }
    }
    if (ret >= 0) {
        f->pos += ret;
    }
    f->buf_index = 0;
    f->iovcnt = 0;
    if (ret < 0) {
        qemu_file_set_error(f, ret);
    }
}

void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
{
    int ret = 0;

    if (f->ops->before_ram_iterate) {
        ret = f->ops->before_ram_iterate(f, f->opaque, flags);
        if (ret < 0) {
            qemu_file_set_error(f, ret);
        }
    }
}

void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
{
    int ret = 0;

    if (f->ops->after_ram_iterate) {
        ret = f->ops->after_ram_iterate(f, f->opaque, flags);
        if (ret < 0) {
            qemu_file_set_error(f, ret);
        }
    }
}

void ram_control_load_hook(QEMUFile *f, uint64_t flags)
{
    int ret = -EINVAL;

    if (f->ops->hook_ram_load) {
        ret = f->ops->hook_ram_load(f, f->opaque, flags);
        if (ret < 0) {
            qemu_file_set_error(f, ret);
        }
    } else {
        qemu_file_set_error(f, ret);
    }
}

size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
                         ram_addr_t offset, size_t size, int *bytes_sent)
{
    if (f->ops->save_page) {
        int ret = f->ops->save_page(f, f->opaque, block_offset,
                                    offset, size, bytes_sent);

        if (ret != RAM_SAVE_CONTROL_DELAYED) {
            if (bytes_sent && *bytes_sent > 0) {
                qemu_update_position(f, *bytes_sent);
            } else if (ret < 0) {
                qemu_file_set_error(f, ret);
            }
        }

        return ret;
    }

    return RAM_SAVE_CONTROL_NOT_SUPP;
}

/*
 * Attempt to fill the buffer from the underlying file
 * Returns the number of bytes read, or negative value for an error.
 *
 * Note that it can return a partially full buffer even in a not error/not EOF
 * case if the underlying file descriptor gives a short read, and that can
 * happen even on a blocking fd.
 */
static ssize_t qemu_fill_buffer(QEMUFile *f)
{
    int len;
    int pending;

    assert(!qemu_file_is_writable(f));

    pending = f->buf_size - f->buf_index;
    if (pending > 0) {
        memmove(f->buf, f->buf + f->buf_index, pending);
    }
    f->buf_index = 0;
    f->buf_size = pending;

    len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
                        IO_BUF_SIZE - pending);
    if (len > 0) {
        f->buf_size += len;
        f->pos += len;
    } else if (len == 0) {
        qemu_file_set_error(f, -EIO);
    } else if (len != -EAGAIN) {
        qemu_file_set_error(f, len);
    }

    return len;
}

int qemu_get_fd(QEMUFile *f)
{
    if (f->ops->get_fd) {
        return f->ops->get_fd(f->opaque);
    }
    return -1;
}

void qemu_update_position(QEMUFile *f, size_t size)
{
    f->pos += size;
}

/** Closes the file
 *
 * Returns negative error value if any error happened on previous operations or
 * while closing the file. Returns 0 or positive number on success.
 *
 * The meaning of return value on success depends on the specific backend
 * being used.
 */
int qemu_fclose(QEMUFile *f)
{
    int ret;
    qemu_fflush(f);
    ret = qemu_file_get_error(f);

    if (f->ops->close) {
        int ret2 = f->ops->close(f->opaque);
        if (ret >= 0) {
            ret = ret2;
        }
    }
    /* If any error was spotted before closing, we should report it
     * instead of the close() return value.
     */
    if (f->last_error) {
        ret = f->last_error;
    }
    g_free(f);
    trace_qemu_file_fclose();
    return ret;
}

static void add_to_iovec(QEMUFile *f, const uint8_t *buf, int size)
{
    /* check for adjacent buffer and coalesce them */
    if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
        f->iov[f->iovcnt - 1].iov_len) {
        f->iov[f->iovcnt - 1].iov_len += size;
    } else {
        f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
        f->iov[f->iovcnt++].iov_len = size;
    }

    if (f->iovcnt >= MAX_IOV_SIZE) {
        qemu_fflush(f);
    }
}

void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size)
{
    if (!f->ops->writev_buffer) {
        qemu_put_buffer(f, buf, size);
        return;
    }

    if (f->last_error) {
        return;
    }

    f->bytes_xfer += size;
    add_to_iovec(f, buf, size);
}

void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
{
    int l;

    if (f->last_error) {
        return;
    }

    while (size > 0) {
        l = IO_BUF_SIZE - f->buf_index;
        if (l > size) {
            l = size;
        }
        memcpy(f->buf + f->buf_index, buf, l);
        f->bytes_xfer += l;
        if (f->ops->writev_buffer) {
            add_to_iovec(f, f->buf + f->buf_index, l);
        }
        f->buf_index += l;
        if (f->buf_index == IO_BUF_SIZE) {
            qemu_fflush(f);
        }
        if (qemu_file_get_error(f)) {
            break;
        }
        buf += l;
        size -= l;
    }
}

void qemu_put_byte(QEMUFile *f, int v)
{
    if (f->last_error) {
        return;
    }

    f->buf[f->buf_index] = v;
    f->bytes_xfer++;
    if (f->ops->writev_buffer) {
        add_to_iovec(f, f->buf + f->buf_index, 1);
    }
    f->buf_index++;
    if (f->buf_index == IO_BUF_SIZE) {
        qemu_fflush(f);
    }
}

void qemu_file_skip(QEMUFile *f, int size)
{
    if (f->buf_index + size <= f->buf_size) {
        f->buf_index += size;
    }
}

/*
 * Read 'size' bytes from file (at 'offset') into buf without moving the
 * pointer.
 *
 * It will return size bytes unless there was an error, in which case it will
 * return as many as it managed to read (assuming blocking fd's which
 * all current QEMUFile are)
 */
int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
{
    int pending;
    int index;

    assert(!qemu_file_is_writable(f));
    assert(offset < IO_BUF_SIZE);
    assert(size <= IO_BUF_SIZE - offset);

    /* The 1st byte to read from */
    index = f->buf_index + offset;
    /* The number of available bytes starting at index */
    pending = f->buf_size - index;

    /*
     * qemu_fill_buffer might return just a few bytes, even when there isn't
     * an error, so loop collecting them until we get enough.
     */
    while (pending < size) {
        int received = qemu_fill_buffer(f);

        if (received <= 0) {
            break;
        }

        index = f->buf_index + offset;
        pending = f->buf_size - index;
    }

    if (pending <= 0) {
        return 0;
    }
    if (size > pending) {
        size = pending;
    }

    memcpy(buf, f->buf + index, size);
    return size;
}

/*
 * Read 'size' bytes of data from the file into buf.
 * 'size' can be larger than the internal buffer.
 *
 * It will return size bytes unless there was an error, in which case it will
 * return as many as it managed to read (assuming blocking fd's which
 * all current QEMUFile are)
 */
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
{
    int pending = size;
    int done = 0;

    while (pending > 0) {
        int res;

        res = qemu_peek_buffer(f, buf, MIN(pending, IO_BUF_SIZE), 0);
        if (res == 0) {
            return done;
        }
        qemu_file_skip(f, res);
        buf += res;
        pending -= res;
        done += res;
    }
    return done;
}

/*
 * Peeks a single byte from the buffer; this isn't guaranteed to work if
 * offset leaves a gap after the previous read/peeked data.
 */
int qemu_peek_byte(QEMUFile *f, int offset)
{
    int index = f->buf_index + offset;

    assert(!qemu_file_is_writable(f));
    assert(offset < IO_BUF_SIZE);

    if (index >= f->buf_size) {
        qemu_fill_buffer(f);
        index = f->buf_index + offset;
        if (index >= f->buf_size) {
            return 0;
        }
    }
    return f->buf[index];
}

int qemu_get_byte(QEMUFile *f)
{
    int result;

    result = qemu_peek_byte(f, 0);
    qemu_file_skip(f, 1);
    return result;
}

int64_t qemu_ftell(QEMUFile *f)
{
    qemu_fflush(f);
    return f->pos;
}

int qemu_file_rate_limit(QEMUFile *f)
{
    if (qemu_file_get_error(f)) {
        return 1;
    }
    if (f->xfer_limit > 0 && f->bytes_xfer > f->xfer_limit) {
        return 1;
    }
    return 0;
}

int64_t qemu_file_get_rate_limit(QEMUFile *f)
{
    return f->xfer_limit;
}

void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
{
    f->xfer_limit = limit;
}

void qemu_file_reset_rate_limit(QEMUFile *f)
{
    f->bytes_xfer = 0;
}

void qemu_put_be16(QEMUFile *f, unsigned int v)
{
    qemu_put_byte(f, v >> 8);
    qemu_put_byte(f, v);
}

void qemu_put_be32(QEMUFile *f, unsigned int v)
{
    qemu_put_byte(f, v >> 24);
    qemu_put_byte(f, v >> 16);
    qemu_put_byte(f, v >> 8);
    qemu_put_byte(f, v);
}

void qemu_put_be64(QEMUFile *f, uint64_t v)
{
    qemu_put_be32(f, v >> 32);
    qemu_put_be32(f, v);
}

unsigned int qemu_get_be16(QEMUFile *f)
{
    unsigned int v;
    v = qemu_get_byte(f) << 8;
    v |= qemu_get_byte(f);
    return v;
}

unsigned int qemu_get_be32(QEMUFile *f)
{
    unsigned int v;
    v = qemu_get_byte(f) << 24;
    v |= qemu_get_byte(f) << 16;
    v |= qemu_get_byte(f) << 8;
    v |= qemu_get_byte(f);
    return v;
}

uint64_t qemu_get_be64(QEMUFile *f)
{
    uint64_t v;
    v = (uint64_t)qemu_get_be32(f) << 32;
    v |= qemu_get_be32(f);
    return v;
}
Commit	Line	Data
093c455a EH	1	#include "qemu-common.h"
	2	#include "qemu/iov.h"
	3	#include "qemu/sockets.h"
	4	#include "block/coroutine.h"
	5	#include "migration/migration.h"
	6	#include "migration/qemu-file.h"
9013dca5	7	#include "trace.h"
093c455a EH	8
	9	#define IO_BUF_SIZE 32768
	10	#define MAX_IOV_SIZE MIN(IOV_MAX, 64)
	11
	12	struct QEMUFile {
	13	const QEMUFileOps *ops;
	14	void *opaque;
	15
	16	int64_t bytes_xfer;
	17	int64_t xfer_limit;
	18
	19	int64_t pos; /* start of buffer when writing, end of buffer
	20	when reading */
	21	int buf_index;
	22	int buf_size; /* 0 when writing */
	23	uint8_t buf[IO_BUF_SIZE];
	24
	25	struct iovec iov[MAX_IOV_SIZE];
	26	unsigned int iovcnt;
	27
	28	int last_error;
	29	};
	30
	31	typedef struct QEMUFileStdio {
	32	FILE *stdio_file;
	33	QEMUFile *file;
	34	} QEMUFileStdio;
	35
	36	typedef struct QEMUFileSocket {
	37	int fd;
	38	QEMUFile *file;
	39	} QEMUFileSocket;
	40
	41	static ssize_t socket_writev_buffer(void opaque, struct iovec iov, int iovcnt,
	42	int64_t pos)
	43	{
	44	QEMUFileSocket *s = opaque;
	45	ssize_t len;
	46	ssize_t size = iov_size(iov, iovcnt);
	47
	48	len = iov_send(s->fd, iov, iovcnt, 0, size);
	49	if (len < size) {
	50	len = -socket_error();
	51	}
	52	return len;
	53	}
	54
	55	static int socket_get_fd(void *opaque)
	56	{
	57	QEMUFileSocket *s = opaque;
	58
	59	return s->fd;
	60	}
	61
	62	static int socket_get_buffer(void opaque, uint8_t buf, int64_t pos, int size)
	63	{
	64	QEMUFileSocket *s = opaque;
	65	ssize_t len;
	66
	67	for (;;) {
	68	len = qemu_recv(s->fd, buf, size, 0);
	69	if (len != -1) {
	70	break;
	71	}
72	if (socket_error() == EAGAIN) {
73	yield_until_fd_readable(s->fd);
74	} else if (socket_error() != EINTR) {
75	break;
76	}
77	}
78
79	if (len == -1) {
80	len = -socket_error();
81	}
82	return len;
83	}
84
85	static int socket_close(void *opaque)
86	{
87	QEMUFileSocket *s = opaque;
88	closesocket(s->fd);
89	g_free(s);
90	return 0;
91	}
92
93	static int stdio_get_fd(void *opaque)
94	{
95	QEMUFileStdio *s = opaque;
96
97	return fileno(s->stdio_file);
98	}
99
100	static int stdio_put_buffer(void opaque, const uint8_t buf, int64_t pos,
101	int size)
102	{
103	QEMUFileStdio *s = opaque;
aded6539 JQ	104	int res;
	105
	106	res = fwrite(buf, 1, size, s->stdio_file);
	107
	108	if (res != size) {
ac4df4e6	109	return -errno;
aded6539 JQ	110	}
aded6539 JQ	111	return res;
093c455a EH	112	}
	113
	114	static int stdio_get_buffer(void opaque, uint8_t buf, int64_t pos, int size)
	115	{
	116	QEMUFileStdio *s = opaque;
	117	FILE *fp = s->stdio_file;
	118	int bytes;
	119
	120	for (;;) {
	121	clearerr(fp);
	122	bytes = fread(buf, 1, size, fp);
	123	if (bytes != 0 \|\| !ferror(fp)) {
	124	break;
	125	}
	126	if (errno == EAGAIN) {
	127	yield_until_fd_readable(fileno(fp));
	128	} else if (errno != EINTR) {
	129	break;
	130	}
	131	}
	132	return bytes;
	133	}
	134
	135	static int stdio_pclose(void *opaque)
	136	{
	137	QEMUFileStdio *s = opaque;
	138	int ret;
	139	ret = pclose(s->stdio_file);
	140	if (ret == -1) {
	141	ret = -errno;
	142	} else if (!WIFEXITED(ret) \|\| WEXITSTATUS(ret) != 0) {
	143	/* close succeeded, but non-zero exit code: */
	144	ret = -EIO; /* fake errno value */
	145	}
	146	g_free(s);
	147	return ret;
	148	}
	149
	150	static int stdio_fclose(void *opaque)
	151	{
	152	QEMUFileStdio *s = opaque;
	153	int ret = 0;
	154
	155	if (s->file->ops->put_buffer \|\| s->file->ops->writev_buffer) {
	156	int fd = fileno(s->stdio_file);
	157	struct stat st;
	158
	159	ret = fstat(fd, &st);
	160	if (ret == 0 && S_ISREG(st.st_mode)) {
	161	/*
	162	* If the file handle is a regular file make sure the
	163	* data is flushed to disk before signaling success.
	164	*/
	165	ret = fsync(fd);
	166	if (ret != 0) {
	167	ret = -errno;
	168	return ret;
	169	}
	170	}
	171	}
	172	if (fclose(s->stdio_file) == EOF) {
	173	ret = -errno;
	174	}
	175	g_free(s);
176	return ret;
177	}
178
179	static const QEMUFileOps stdio_pipe_read_ops = {
180	.get_fd = stdio_get_fd,
181	.get_buffer = stdio_get_buffer,
182	.close = stdio_pclose
183	};
184
185	static const QEMUFileOps stdio_pipe_write_ops = {
186	.get_fd = stdio_get_fd,
187	.put_buffer = stdio_put_buffer,
188	.close = stdio_pclose
189	};
190
191	QEMUFile qemu_popen_cmd(const char command, const char *mode)
192	{
193	FILE *stdio_file;
194	QEMUFileStdio *s;
195
196	if (mode == NULL \|\| (mode[0] != 'r' && mode[0] != 'w') \|\| mode[1] != 0) {
197	fprintf(stderr, "qemu_popen: Argument validity check failed\n");
198	return NULL;
199	}
200
201	stdio_file = popen(command, mode);
202	if (stdio_file == NULL) {
203	return NULL;
204	}
205
206	s = g_malloc0(sizeof(QEMUFileStdio));
207
208	s->stdio_file = stdio_file;
209
210	if (mode[0] == 'r') {
211	s->file = qemu_fopen_ops(s, &stdio_pipe_read_ops);
212	} else {
213	s->file = qemu_fopen_ops(s, &stdio_pipe_write_ops);
214	}
215	return s->file;
216	}
217
218	static const QEMUFileOps stdio_file_read_ops = {
219	.get_fd = stdio_get_fd,
220	.get_buffer = stdio_get_buffer,
221	.close = stdio_fclose
222	};
223
224	static const QEMUFileOps stdio_file_write_ops = {
225	.get_fd = stdio_get_fd,
226	.put_buffer = stdio_put_buffer,
227	.close = stdio_fclose
228	};
229
230	static ssize_t unix_writev_buffer(void opaque, struct iovec iov, int iovcnt,
231	int64_t pos)
232	{
233	QEMUFileSocket *s = opaque;
234	ssize_t len, offset;
235	ssize_t size = iov_size(iov, iovcnt);
236	ssize_t total = 0;
237
238	assert(iovcnt > 0);
239	offset = 0;
240	while (size > 0) {
241	/* Find the next start position; skip all full-sized vector elements */
242	while (offset >= iov[0].iov_len) {
243	offset -= iov[0].iov_len;
244	iov++, iovcnt--;
245	}
246
247	/* skip `offset' bytes from the (now) first element, undo it on exit */
248	assert(iovcnt > 0);
249	iov[0].iov_base += offset;
250	iov[0].iov_len -= offset;
251
252	do {
253	len = writev(s->fd, iov, iovcnt);
254	} while (len == -1 && errno == EINTR);
255	if (len == -1) {
256	return -errno;
257	}
258
259	/* Undo the changes above */
260	iov[0].iov_base -= offset;
261	iov[0].iov_len += offset;
262
263	/* Prepare for the next iteration */
264	offset += len;
265	total += len;
266	size -= len;
267	}
268
269	return total;
270	}
271
272	static int unix_get_buffer(void opaque, uint8_t buf, int64_t pos, int size)
273	{
274	QEMUFileSocket *s = opaque;
275	ssize_t len;
276
277	for (;;) {
278	len = read(s->fd, buf, size);
279	if (len != -1) {
280	break;
281	}
282	if (errno == EAGAIN) {
283	yield_until_fd_readable(s->fd);
284	} else if (errno != EINTR) {
285	break;
286	}
287	}
288
289	if (len == -1) {
290	len = -errno;
291	}
292	return len;
293	}
294
295	static int unix_close(void *opaque)
296	{
297	QEMUFileSocket *s = opaque;
298	close(s->fd);
299	g_free(s);
300	return 0;
301	}
302
303	static const QEMUFileOps unix_read_ops = {
304	.get_fd = socket_get_fd,
305	.get_buffer = unix_get_buffer,
306	.close = unix_close
307	};
308
309	static const QEMUFileOps unix_write_ops = {
310	.get_fd = socket_get_fd,
311	.writev_buffer = unix_writev_buffer,
312	.close = unix_close
313	};
314
315	QEMUFile qemu_fdopen(int fd, const char mode)
316	{
317	QEMUFileSocket *s;
318
319	if (mode == NULL \|\|
320	(mode[0] != 'r' && mode[0] != 'w') \|\|
321	mode[1] != 'b' \|\| mode[2] != 0) {
322	fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
323	return NULL;
324	}
325
326	s = g_malloc0(sizeof(QEMUFileSocket));
327	s->fd = fd;
328
329	if (mode[0] == 'r') {
330	s->file = qemu_fopen_ops(s, &unix_read_ops);
331	} else {
332	s->file = qemu_fopen_ops(s, &unix_write_ops);
333	}
334	return s->file;
335	}
336
337	static const QEMUFileOps socket_read_ops = {
338	.get_fd = socket_get_fd,
339	.get_buffer = socket_get_buffer,
340	.close = socket_close
341	};
342
343	static const QEMUFileOps socket_write_ops = {
344	.get_fd = socket_get_fd,
345	.writev_buffer = socket_writev_buffer,
346	.close = socket_close
347	};
348
349	bool qemu_file_mode_is_not_valid(const char *mode)
350	{
351	if (mode == NULL \|\|
352	(mode[0] != 'r' && mode[0] != 'w') \|\|
353	mode[1] != 'b' \|\| mode[2] != 0) {
354	fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
355	return true;
356	}
357
358	return false;
359	}
360
361	QEMUFile qemu_fopen_socket(int fd, const char mode)
362	{
363	QEMUFileSocket *s;
364
365	if (qemu_file_mode_is_not_valid(mode)) {
366	return NULL;
367	}
368
369	s = g_malloc0(sizeof(QEMUFileSocket));
370	s->fd = fd;
371	if (mode[0] == 'w') {
372	qemu_set_block(s->fd);
373	s->file = qemu_fopen_ops(s, &socket_write_ops);
374	} else {
375	s->file = qemu_fopen_ops(s, &socket_read_ops);
376	}
377	return s->file;
378	}
379
380	QEMUFile qemu_fopen(const char filename, const char *mode)
381	{
382	QEMUFileStdio *s;
383
384	if (qemu_file_mode_is_not_valid(mode)) {
385	return NULL;
386	}
387
388	s = g_malloc0(sizeof(QEMUFileStdio));
389
390	s->stdio_file = fopen(filename, mode);
391	if (!s->stdio_file) {
392	goto fail;
393	}
394
395	if (mode[0] == 'w') {
396	s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
397	} else {
398	s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
399	}
400	return s->file;
401	fail:
402	g_free(s);
403	return NULL;
404	}
405
406	QEMUFile qemu_fopen_ops(void opaque, const QEMUFileOps *ops)
407	{
408	QEMUFile *f;
409
410	f = g_malloc0(sizeof(QEMUFile));
411
412	f->opaque = opaque;
413	f->ops = ops;
414	return f;
415	}
416
417	/*
418	* Get last error for stream f
419	*
420	* Return negative error value if there has been an error on previous
421	* operations, return 0 if no error happened.
422	*
423	*/
424	int qemu_file_get_error(QEMUFile *f)
425	{
426	return f->last_error;
427	}
428
429	void qemu_file_set_error(QEMUFile *f, int ret)
430	{
431	if (f->last_error == 0) {
432	f->last_error = ret;
433	}
434	}
435
436	static inline bool qemu_file_is_writable(QEMUFile *f)
437	{
438	return f->ops->writev_buffer \|\| f->ops->put_buffer;
439	}
440
441	/**
442	* Flushes QEMUFile buffer
443	*
444	* If there is writev_buffer QEMUFileOps it uses it otherwise uses
445	* put_buffer ops.
446	*/
447	void qemu_fflush(QEMUFile *f)
448	{
449	ssize_t ret = 0;
450
451	if (!qemu_file_is_writable(f)) {
452	return;
453	}
454
455	if (f->ops->writev_buffer) {
456	if (f->iovcnt > 0) {
457	ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos);
458	}
459	} else {
460	if (f->buf_index > 0) {
461	ret = f->ops->put_buffer(f->opaque, f->buf, f->pos, f->buf_index);
462	}
463	}
464	if (ret >= 0) {
465	f->pos += ret;
466	}
467	f->buf_index = 0;
468	f->iovcnt = 0;
469	if (ret < 0) {
470	qemu_file_set_error(f, ret);
471	}
472	}
473
474	void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
475	{
476	int ret = 0;
477
478	if (f->ops->before_ram_iterate) {
479	ret = f->ops->before_ram_iterate(f, f->opaque, flags);
480	if (ret < 0) {
481	qemu_file_set_error(f, ret);
482	}
483	}
484	}
485
486	void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
487	{
488	int ret = 0;
489
490	if (f->ops->after_ram_iterate) {
491	ret = f->ops->after_ram_iterate(f, f->opaque, flags);
492	if (ret < 0) {
493	qemu_file_set_error(f, ret);
494	}
495	}
496	}
497
498	void ram_control_load_hook(QEMUFile *f, uint64_t flags)
499	{
500	int ret = -EINVAL;
501
502	if (f->ops->hook_ram_load) {
503	ret = f->ops->hook_ram_load(f, f->opaque, flags);
504	if (ret < 0) {
505	qemu_file_set_error(f, ret);
506	}
507	} else {
508	qemu_file_set_error(f, ret);
509	}
510	}
511
512	size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
513	ram_addr_t offset, size_t size, int *bytes_sent)
514	{
515	if (f->ops->save_page) {
516	int ret = f->ops->save_page(f, f->opaque, block_offset,
517	offset, size, bytes_sent);
518
519	if (ret != RAM_SAVE_CONTROL_DELAYED) {
520	if (bytes_sent && *bytes_sent > 0) {
521	qemu_update_position(f, *bytes_sent);
522	} else if (ret < 0) {
523	qemu_file_set_error(f, ret);
524	}
525	}
526
527	return ret;
528	}
529
530	return RAM_SAVE_CONTROL_NOT_SUPP;
531	}
532
548f52ea DDAG	533	/*
	534	* Attempt to fill the buffer from the underlying file
	535	* Returns the number of bytes read, or negative value for an error.
	536	*
	537	* Note that it can return a partially full buffer even in a not error/not EOF
	538	* case if the underlying file descriptor gives a short read, and that can
	539	* happen even on a blocking fd.
	540	*/
	541	static ssize_t qemu_fill_buffer(QEMUFile *f)
093c455a EH	542	{
	543	int len;
	544	int pending;
	545
	546	assert(!qemu_file_is_writable(f));
	547
	548	pending = f->buf_size - f->buf_index;
	549	if (pending > 0) {
	550	memmove(f->buf, f->buf + f->buf_index, pending);
	551	}
	552	f->buf_index = 0;
	553	f->buf_size = pending;
	554
	555	len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
	556	IO_BUF_SIZE - pending);
	557	if (len > 0) {
	558	f->buf_size += len;
	559	f->pos += len;
	560	} else if (len == 0) {
	561	qemu_file_set_error(f, -EIO);
	562	} else if (len != -EAGAIN) {
	563	qemu_file_set_error(f, len);
	564	}
548f52ea DDAG	565
548f52ea DDAG	566	return len;
093c455a EH	567	}
	568
	569	int qemu_get_fd(QEMUFile *f)
	570	{
	571	if (f->ops->get_fd) {
	572	return f->ops->get_fd(f->opaque);
	573	}
	574	return -1;
	575	}
	576
	577	void qemu_update_position(QEMUFile *f, size_t size)
	578	{
	579	f->pos += size;
	580	}
	581
	582	/** Closes the file
	583	*
	584	* Returns negative error value if any error happened on previous operations or
	585	* while closing the file. Returns 0 or positive number on success.
	586	*
	587	* The meaning of return value on success depends on the specific backend
	588	* being used.
	589	*/
	590	int qemu_fclose(QEMUFile *f)
	591	{
	592	int ret;
	593	qemu_fflush(f);
	594	ret = qemu_file_get_error(f);
	595
	596	if (f->ops->close) {
	597	int ret2 = f->ops->close(f->opaque);
	598	if (ret >= 0) {
	599	ret = ret2;
	600	}
	601	}
	602	/* If any error was spotted before closing, we should report it
	603	* instead of the close() return value.
	604	*/
	605	if (f->last_error) {
	606	ret = f->last_error;
	607	}
	608	g_free(f);
9013dca5	609	trace_qemu_file_fclose();
093c455a EH	610	return ret;
	611	}
	612
	613	static void add_to_iovec(QEMUFile f, const uint8_t buf, int size)
	614	{
	615	/* check for adjacent buffer and coalesce them */
	616	if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
	617	f->iov[f->iovcnt - 1].iov_len) {
	618	f->iov[f->iovcnt - 1].iov_len += size;
	619	} else {
	620	f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
	621	f->iov[f->iovcnt++].iov_len = size;
	622	}
	623
	624	if (f->iovcnt >= MAX_IOV_SIZE) {
	625	qemu_fflush(f);
	626	}
	627	}
	628
	629	void qemu_put_buffer_async(QEMUFile f, const uint8_t buf, int size)
	630	{
	631	if (!f->ops->writev_buffer) {
	632	qemu_put_buffer(f, buf, size);
	633	return;
	634	}
	635
	636	if (f->last_error) {
	637	return;
	638	}
	639
	640	f->bytes_xfer += size;
	641	add_to_iovec(f, buf, size);
	642	}
	643
	644	void qemu_put_buffer(QEMUFile f, const uint8_t buf, int size)
	645	{
	646	int l;
	647
	648	if (f->last_error) {
	649	return;
	650	}
	651
	652	while (size > 0) {
	653	l = IO_BUF_SIZE - f->buf_index;
	654	if (l > size) {
	655	l = size;
	656	}
	657	memcpy(f->buf + f->buf_index, buf, l);
	658	f->bytes_xfer += l;
	659	if (f->ops->writev_buffer) {
	660	add_to_iovec(f, f->buf + f->buf_index, l);
	661	}
	662	f->buf_index += l;
	663	if (f->buf_index == IO_BUF_SIZE) {
	664	qemu_fflush(f);
	665	}
	666	if (qemu_file_get_error(f)) {
	667	break;
	668	}
	669	buf += l;
	670	size -= l;
	671	}
	672	}
	673
674	void qemu_put_byte(QEMUFile *f, int v)
675	{
676	if (f->last_error) {
677	return;
678	}
679
680	f->buf[f->buf_index] = v;
681	f->bytes_xfer++;
682	if (f->ops->writev_buffer) {
683	add_to_iovec(f, f->buf + f->buf_index, 1);
684	}
685	f->buf_index++;
686	if (f->buf_index == IO_BUF_SIZE) {
687	qemu_fflush(f);
688	}
689	}
690
691	void qemu_file_skip(QEMUFile *f, int size)
692	{
693	if (f->buf_index + size <= f->buf_size) {
694	f->buf_index += size;
695	}
696	}
697
548f52ea DDAG	698	/*
	699	* Read 'size' bytes from file (at 'offset') into buf without moving the
	700	* pointer.
	701	*
	702	* It will return size bytes unless there was an error, in which case it will
	703	* return as many as it managed to read (assuming blocking fd's which
	704	* all current QEMUFile are)
	705	*/
093c455a EH	706	int qemu_peek_buffer(QEMUFile f, uint8_t buf, int size, size_t offset)
	707	{
	708	int pending;
	709	int index;
	710
	711	assert(!qemu_file_is_writable(f));
548f52ea DDAG	712	assert(offset < IO_BUF_SIZE);
548f52ea DDAG	713	assert(size <= IO_BUF_SIZE - offset);
093c455a	714
548f52ea	715	/* The 1st byte to read from */
093c455a	716	index = f->buf_index + offset;
548f52ea	717	/* The number of available bytes starting at index */
093c455a	718	pending = f->buf_size - index;
548f52ea DDAG	719
	720	/*
	721	* qemu_fill_buffer might return just a few bytes, even when there isn't
	722	* an error, so loop collecting them until we get enough.
	723	*/
	724	while (pending < size) {
	725	int received = qemu_fill_buffer(f);
	726
	727	if (received <= 0) {
	728	break;
	729	}
	730
093c455a EH	731	index = f->buf_index + offset;
	732	pending = f->buf_size - index;
	733	}
	734
	735	if (pending <= 0) {
	736	return 0;
	737	}
	738	if (size > pending) {
	739	size = pending;
	740	}
	741
	742	memcpy(buf, f->buf + index, size);
	743	return size;
	744	}
	745
548f52ea DDAG	746	/*
	747	* Read 'size' bytes of data from the file into buf.
	748	* 'size' can be larger than the internal buffer.
	749	*
	750	* It will return size bytes unless there was an error, in which case it will
	751	* return as many as it managed to read (assuming blocking fd's which
	752	* all current QEMUFile are)
	753	*/
093c455a EH	754	int qemu_get_buffer(QEMUFile f, uint8_t buf, int size)
	755	{
	756	int pending = size;
	757	int done = 0;
	758
	759	while (pending > 0) {
	760	int res;
	761
548f52ea	762	res = qemu_peek_buffer(f, buf, MIN(pending, IO_BUF_SIZE), 0);
093c455a EH	763	if (res == 0) {
	764	return done;
	765	}
	766	qemu_file_skip(f, res);
	767	buf += res;
	768	pending -= res;
	769	done += res;
	770	}
	771	return done;
	772	}
	773
548f52ea DDAG	774	/*
	775	* Peeks a single byte from the buffer; this isn't guaranteed to work if
	776	* offset leaves a gap after the previous read/peeked data.
	777	*/
093c455a EH	778	int qemu_peek_byte(QEMUFile *f, int offset)
	779	{
	780	int index = f->buf_index + offset;
	781
	782	assert(!qemu_file_is_writable(f));
548f52ea	783	assert(offset < IO_BUF_SIZE);
093c455a EH	784
	785	if (index >= f->buf_size) {
	786	qemu_fill_buffer(f);
	787	index = f->buf_index + offset;
	788	if (index >= f->buf_size) {
	789	return 0;
	790	}
	791	}
	792	return f->buf[index];
	793	}
	794
	795	int qemu_get_byte(QEMUFile *f)
	796	{
	797	int result;
	798
	799	result = qemu_peek_byte(f, 0);
	800	qemu_file_skip(f, 1);
	801	return result;
	802	}
	803
	804	int64_t qemu_ftell(QEMUFile *f)
	805	{
	806	qemu_fflush(f);
	807	return f->pos;
	808	}
	809
	810	int qemu_file_rate_limit(QEMUFile *f)
	811	{
	812	if (qemu_file_get_error(f)) {
	813	return 1;
	814	}
	815	if (f->xfer_limit > 0 && f->bytes_xfer > f->xfer_limit) {
	816	return 1;
	817	}
	818	return 0;
	819	}
	820
	821	int64_t qemu_file_get_rate_limit(QEMUFile *f)
	822	{
	823	return f->xfer_limit;
	824	}
	825
	826	void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
	827	{
	828	f->xfer_limit = limit;
	829	}
	830
	831	void qemu_file_reset_rate_limit(QEMUFile *f)
	832	{
	833	f->bytes_xfer = 0;
	834	}
	835
	836	void qemu_put_be16(QEMUFile *f, unsigned int v)
	837	{
	838	qemu_put_byte(f, v >> 8);
	839	qemu_put_byte(f, v);
	840	}
	841
	842	void qemu_put_be32(QEMUFile *f, unsigned int v)
	843	{
	844	qemu_put_byte(f, v >> 24);
	845	qemu_put_byte(f, v >> 16);
	846	qemu_put_byte(f, v >> 8);
	847	qemu_put_byte(f, v);
848	}
849
850	void qemu_put_be64(QEMUFile *f, uint64_t v)
851	{
852	qemu_put_be32(f, v >> 32);
853	qemu_put_be32(f, v);
854	}
855
856	unsigned int qemu_get_be16(QEMUFile *f)
857	{
858	unsigned int v;
859	v = qemu_get_byte(f) << 8;
860	v \|= qemu_get_byte(f);
861	return v;
862	}
863
864	unsigned int qemu_get_be32(QEMUFile *f)
865	{
866	unsigned int v;
867	v = qemu_get_byte(f) << 24;
868	v \|= qemu_get_byte(f) << 16;
869	v \|= qemu_get_byte(f) << 8;
870	v \|= qemu_get_byte(f);
871	return v;
872	}
873
874	uint64_t qemu_get_be64(QEMUFile *f)
875	{
876	uint64_t v;
877	v = (uint64_t)qemu_get_be32(f) << 32;
878	v \|= qemu_get_be32(f);
879	return v;
880	}