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 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-watch.h"
  24 #include "qemu/sockets.h"
  25 #include "trace.h"
  26
  27 QIOChannelFile *
  28 qio_channel_file_new_fd(int fd)
  29 {
  30     QIOChannelFile *ioc;
  31
  32     ioc = QIO_CHANNEL_FILE(object_new(TYPE_QIO_CHANNEL_FILE));
  33
  34     ioc->fd = fd;
  35
  36     trace_qio_channel_file_new_fd(ioc, fd);
  37
  38     return ioc;
  39 }
  40
  41
  42 QIOChannelFile *
  43 qio_channel_file_new_path(const char *path,
  44                           int flags,
  45                           mode_t mode,
  46                           Error **errp)
  47 {
  48     QIOChannelFile *ioc;
  49
  50     ioc = QIO_CHANNEL_FILE(object_new(TYPE_QIO_CHANNEL_FILE));
  51
  52     if (flags & O_WRONLY) {
  53         ioc->fd = open(path, flags, mode);
  54     } else {
  55         ioc->fd = open(path, flags);
  56     }
  57     if (ioc->fd < 0) {
  58         object_unref(OBJECT(ioc));
  59         error_setg_errno(errp, errno,
  60                          "Unable to open %s", path);
  61         return NULL;
  62     }
  63
  64     trace_qio_channel_file_new_path(ioc, path, flags, mode, ioc->fd);
  65
  66     return ioc;
  67 }
  68
  69
  70 static void qio_channel_file_init(Object *obj)
  71 {
  72     QIOChannelFile *ioc = QIO_CHANNEL_FILE(obj);
  73     ioc->fd = -1;
  74 }
  75
  76 static void qio_channel_file_finalize(Object *obj)
  77 {
  78     QIOChannelFile *ioc = QIO_CHANNEL_FILE(obj);
  79     if (ioc->fd != -1) {
  80         close(ioc->fd);
  81         ioc->fd = -1;
  82     }
  83 }
  84
  85
  86 static ssize_t qio_channel_file_readv(QIOChannel *ioc,
  87                                       const struct iovec *iov,
  88                                       size_t niov,
  89                                       int **fds,
  90                                       size_t *nfds,
  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                                        Error **errp)
 120 {
 121     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 122     ssize_t ret;
 123
 124  retry:
 125     ret = writev(fioc->fd, iov, niov);
 126     if (ret <= 0) {
 127         if (errno == EAGAIN) {
 128             return QIO_CHANNEL_ERR_BLOCK;
 129         }
 130         if (errno == EINTR) {
 131             goto retry;
 132         }
 133         error_setg_errno(errp, errno,
 134                          "Unable to write to file");
 135         return -1;
 136     }
 137     return ret;
 138 }
 139
 140 static int qio_channel_file_set_blocking(QIOChannel *ioc,
 141                                          bool enabled,
 142                                          Error **errp)
 143 {
 144     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 145
 146     if (enabled) {
 147         qemu_set_block(fioc->fd);
 148     } else {
 149         qemu_set_nonblock(fioc->fd);
 150     }
 151     return 0;
 152 }
 153
 154
 155 static off_t qio_channel_file_seek(QIOChannel *ioc,
 156                                    off_t offset,
 157                                    int whence,
 158                                    Error **errp)
 159 {
 160     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 161     off_t ret;
 162
 163     ret = lseek(fioc->fd, offset, whence);
 164     if (ret == (off_t)-1) {
 165         error_setg_errno(errp, errno,
 166                          "Unable to seek to offset %lld whence %d in file",
 167                          (long long int)offset, whence);
 168         return -1;
 169     }
 170     return ret;
 171 }
 172
 173
 174 static int qio_channel_file_close(QIOChannel *ioc,
 175                                   Error **errp)
 176 {
 177     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 178
 179     if (close(fioc->fd) < 0) {
 180         error_setg_errno(errp, errno,
 181                          "Unable to close file");
 182         return -1;
 183     }
 184     return 0;
 185 }
 186
 187
 188 static GSource *qio_channel_file_create_watch(QIOChannel *ioc,
 189                                               GIOCondition condition)
 190 {
 191     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 192     return qio_channel_create_fd_watch(ioc,
 193                                        fioc->fd,
 194                                        condition);
 195 }
 196
 197 static void qio_channel_file_class_init(ObjectClass *klass,
 198                                         void *class_data G_GNUC_UNUSED)
 199 {
 200     QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
 201
 202     ioc_klass->io_writev = qio_channel_file_writev;
 203     ioc_klass->io_readv = qio_channel_file_readv;
 204     ioc_klass->io_set_blocking = qio_channel_file_set_blocking;
 205     ioc_klass->io_seek = qio_channel_file_seek;
 206     ioc_klass->io_close = qio_channel_file_close;
 207     ioc_klass->io_create_watch = qio_channel_file_create_watch;
 208 }
 209
 210 static const TypeInfo qio_channel_file_info = {
 211     .parent = TYPE_QIO_CHANNEL,
 212     .name = TYPE_QIO_CHANNEL_FILE,
 213     .instance_size = sizeof(QIOChannelFile),
 214     .instance_init = qio_channel_file_init,
 215     .instance_finalize = qio_channel_file_finalize,
 216     .class_init = qio_channel_file_class_init,
 217 };
 218
 219 static void qio_channel_file_register_types(void)
 220 {
 221     type_register_static(&qio_channel_file_info);
 222 }
 223
 224 type_init(qio_channel_file_register_types);