io/channel-file.c

   1 /*
   2  * QEMU I/O channels files driver
   3  *
   4  * Copyright (c) 2015 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "io/channel-file.h"
  23 #include "io/channel-util.h"
  24 #include "io/channel-watch.h"
  25 #include "qapi/error.h"
  26 #include "qemu/module.h"
  27 #include "qemu/sockets.h"
  28 #include "trace.h"
  29
  30 QIOChannelFile *
  31 qio_channel_file_new_fd(int fd)
  32 {
  33     QIOChannelFile *ioc;
  34
  35     ioc = QIO_CHANNEL_FILE(object_new(TYPE_QIO_CHANNEL_FILE));
  36
  37     ioc->fd = fd;
  38
  39     trace_qio_channel_file_new_fd(ioc, fd);
  40
  41     return ioc;
  42 }
  43
  44
  45 QIOChannelFile *
  46 qio_channel_file_new_path(const char *path,
  47                           int flags,
  48                           mode_t mode,
  49                           Error **errp)
  50 {
  51     QIOChannelFile *ioc;
  52
  53     ioc = QIO_CHANNEL_FILE(object_new(TYPE_QIO_CHANNEL_FILE));
  54
  55     ioc->fd = qemu_open_old(path, flags, mode);
  56     if (ioc->fd < 0) {
  57         object_unref(OBJECT(ioc));
  58         error_setg_errno(errp, errno,
  59                          "Unable to open %s", path);
  60         return NULL;
  61     }
  62
  63     trace_qio_channel_file_new_path(ioc, path, flags, mode, ioc->fd);
  64
  65     return ioc;
  66 }
  67
  68
  69 static void qio_channel_file_init(Object *obj)
  70 {
  71     QIOChannelFile *ioc = QIO_CHANNEL_FILE(obj);
  72     ioc->fd = -1;
  73 }
  74
  75 static void qio_channel_file_finalize(Object *obj)
  76 {
  77     QIOChannelFile *ioc = QIO_CHANNEL_FILE(obj);
  78     if (ioc->fd != -1) {
  79         qemu_close(ioc->fd);
  80         ioc->fd = -1;
  81     }
  82 }
  83
  84
  85 static ssize_t qio_channel_file_readv(QIOChannel *ioc,
  86                                       const struct iovec *iov,
  87                                       size_t niov,
  88                                       int **fds,
  89                                       size_t *nfds,
  90                                       int flags,
  91                                       Error **errp)
  92 {
  93     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
  94     ssize_t ret;
  95
  96  retry:
  97     ret = readv(fioc->fd, iov, niov);
  98     if (ret < 0) {
  99         if (errno == EAGAIN) {
 100             return QIO_CHANNEL_ERR_BLOCK;
 101         }
 102         if (errno == EINTR) {
 103             goto retry;
 104         }
 105
 106         error_setg_errno(errp, errno,
 107                          "Unable to read from file");
 108         return -1;
 109     }
 110
 111     return ret;
 112 }
 113
 114 static ssize_t qio_channel_file_writev(QIOChannel *ioc,
 115                                        const struct iovec *iov,
 116                                        size_t niov,
 117                                        int *fds,
 118                                        size_t nfds,
 119                                        int flags,
 120                                        Error **errp)
 121 {
 122     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 123     ssize_t ret;
 124
 125  retry:
 126     ret = writev(fioc->fd, iov, niov);
 127     if (ret <= 0) {
 128         if (errno == EAGAIN) {
 129             return QIO_CHANNEL_ERR_BLOCK;
 130         }
 131         if (errno == EINTR) {
 132             goto retry;
 133         }
 134         error_setg_errno(errp, errno,
 135                          "Unable to write to file");
 136         return -1;
 137     }
 138     return ret;
 139 }
 140
 141 static int qio_channel_file_set_blocking(QIOChannel *ioc,
 142                                          bool enabled,
 143                                          Error **errp)
 144 {
 145 #ifdef WIN32
 146     /* not implemented */
 147     error_setg_errno(errp, errno, "Failed to set FD nonblocking");
 148     return -1;
 149 #else
 150     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 151
 152     if (!g_unix_set_fd_nonblocking(fioc->fd, !enabled, NULL)) {
 153         error_setg_errno(errp, errno, "Failed to set FD nonblocking");
 154         return -1;
 155     }
 156     return 0;
 157 #endif
 158 }
 159
 160
 161 static off_t qio_channel_file_seek(QIOChannel *ioc,
 162                                    off_t offset,
 163                                    int whence,
 164                                    Error **errp)
 165 {
 166     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 167     off_t ret;
 168
 169     ret = lseek(fioc->fd, offset, whence);
 170     if (ret == (off_t)-1) {
 171         error_setg_errno(errp, errno,
 172                          "Unable to seek to offset %lld whence %d in file",
 173                          (long long int)offset, whence);
 174         return -1;
 175     }
 176     return ret;
 177 }
 178
 179
 180 static int qio_channel_file_close(QIOChannel *ioc,
 181                                   Error **errp)
 182 {
 183     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 184
 185     if (qemu_close(fioc->fd) < 0) {
 186         error_setg_errno(errp, errno,
 187                          "Unable to close file");
 188         return -1;
 189     }
 190     fioc->fd = -1;
 191     return 0;
 192 }
 193
 194
 195 static void qio_channel_file_set_aio_fd_handler(QIOChannel *ioc,
 196                                                 AioContext *read_ctx,
 197                                                 IOHandler *io_read,
 198                                                 AioContext *write_ctx,
 199                                                 IOHandler *io_write,
 200                                                 void *opaque)
 201 {
 202     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 203
 204     qio_channel_util_set_aio_fd_handler(fioc->fd, read_ctx, io_read,
 205                                         fioc->fd, write_ctx, io_write,
 206                                         opaque);
 207 }
 208
 209 static GSource *qio_channel_file_create_watch(QIOChannel *ioc,
 210                                               GIOCondition condition)
 211 {
 212     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 213     return qio_channel_create_fd_watch(ioc,
 214                                        fioc->fd,
 215                                        condition);
 216 }
 217
 218 static void qio_channel_file_class_init(ObjectClass *klass,
 219                                         void *class_data G_GNUC_UNUSED)
 220 {
 221     QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
 222
 223     ioc_klass->io_writev = qio_channel_file_writev;
 224     ioc_klass->io_readv = qio_channel_file_readv;
 225     ioc_klass->io_set_blocking = qio_channel_file_set_blocking;
 226     ioc_klass->io_seek = qio_channel_file_seek;
 227     ioc_klass->io_close = qio_channel_file_close;
 228     ioc_klass->io_create_watch = qio_channel_file_create_watch;
 229     ioc_klass->io_set_aio_fd_handler = qio_channel_file_set_aio_fd_handler;
 230 }
 231
 232 static const TypeInfo qio_channel_file_info = {
 233     .parent = TYPE_QIO_CHANNEL,
 234     .name = TYPE_QIO_CHANNEL_FILE,
 235     .instance_size = sizeof(QIOChannelFile),
 236     .instance_init = qio_channel_file_init,
 237     .instance_finalize = qio_channel_file_finalize,
 238     .class_init = qio_channel_file_class_init,
 239 };
 240
 241 static void qio_channel_file_register_types(void)
 242 {
 243     type_register_static(&qio_channel_file_info);
 244 }
 245
 246 type_init(qio_channel_file_register_types);