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-watch.h"
  24 #include "qapi/error.h"
  25 #include "qemu/module.h"
  26 #include "qemu/sockets.h"
  27 #include "trace.h"
  28
  29 QIOChannelFile *
  30 qio_channel_file_new_fd(int fd)
  31 {
  32     QIOChannelFile *ioc;
  33
  34     ioc = QIO_CHANNEL_FILE(object_new(TYPE_QIO_CHANNEL_FILE));
  35
  36     ioc->fd = fd;
  37
  38     trace_qio_channel_file_new_fd(ioc, fd);
  39
  40     return ioc;
  41 }
  42
  43
  44 QIOChannelFile *
  45 qio_channel_file_new_path(const char *path,
  46                           int flags,
  47                           mode_t mode,
  48                           Error **errp)
  49 {
  50     QIOChannelFile *ioc;
  51
  52     ioc = QIO_CHANNEL_FILE(object_new(TYPE_QIO_CHANNEL_FILE));
  53
  54     ioc->fd = qemu_open_old(path, flags, mode);
  55     if (ioc->fd < 0) {
  56         object_unref(OBJECT(ioc));
  57         error_setg_errno(errp, errno,
  58                          "Unable to open %s", path);
  59         return NULL;
  60     }
  61
  62     trace_qio_channel_file_new_path(ioc, path, flags, mode, ioc->fd);
  63
  64     return ioc;
  65 }
  66
  67
  68 static void qio_channel_file_init(Object *obj)
  69 {
  70     QIOChannelFile *ioc = QIO_CHANNEL_FILE(obj);
  71     ioc->fd = -1;
  72 }
  73
  74 static void qio_channel_file_finalize(Object *obj)
  75 {
  76     QIOChannelFile *ioc = QIO_CHANNEL_FILE(obj);
  77     if (ioc->fd != -1) {
  78         qemu_close(ioc->fd);
  79         ioc->fd = -1;
  80     }
  81 }
  82
  83
  84 static ssize_t qio_channel_file_readv(QIOChannel *ioc,
  85                                       const struct iovec *iov,
  86                                       size_t niov,
  87                                       int **fds,
  88                                       size_t *nfds,
  89                                       int flags,
  90                                       Error **errp)
  91 {
  92     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
  93     ssize_t ret;
  94
  95  retry:
  96     ret = readv(fioc->fd, iov, niov);
  97     if (ret < 0) {
  98         if (errno == EAGAIN) {
  99             return QIO_CHANNEL_ERR_BLOCK;
 100         }
 101         if (errno == EINTR) {
 102             goto retry;
 103         }
 104
 105         error_setg_errno(errp, errno,
 106                          "Unable to read from file");
 107         return -1;
 108     }
 109
 110     return ret;
 111 }
 112
 113 static ssize_t qio_channel_file_writev(QIOChannel *ioc,
 114                                        const struct iovec *iov,
 115                                        size_t niov,
 116                                        int *fds,
 117                                        size_t nfds,
 118                                        int flags,
 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 #ifdef WIN32
 145     /* not implemented */
 146     error_setg_errno(errp, errno, "Failed to set FD nonblocking");
 147     return -1;
 148 #else
 149     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 150
 151     if (!g_unix_set_fd_nonblocking(fioc->fd, !enabled, NULL)) {
 152         error_setg_errno(errp, errno, "Failed to set FD nonblocking");
 153         return -1;
 154     }
 155     return 0;
 156 #endif
 157 }
 158
 159
 160 static off_t qio_channel_file_seek(QIOChannel *ioc,
 161                                    off_t offset,
 162                                    int whence,
 163                                    Error **errp)
 164 {
 165     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 166     off_t ret;
 167
 168     ret = lseek(fioc->fd, offset, whence);
 169     if (ret == (off_t)-1) {
 170         error_setg_errno(errp, errno,
 171                          "Unable to seek to offset %lld whence %d in file",
 172                          (long long int)offset, whence);
 173         return -1;
 174     }
 175     return ret;
 176 }
 177
 178
 179 static int qio_channel_file_close(QIOChannel *ioc,
 180                                   Error **errp)
 181 {
 182     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 183
 184     if (qemu_close(fioc->fd) < 0) {
 185         error_setg_errno(errp, errno,
 186                          "Unable to close file");
 187         return -1;
 188     }
 189     fioc->fd = -1;
 190     return 0;
 191 }
 192
 193
 194 static void qio_channel_file_set_aio_fd_handler(QIOChannel *ioc,
 195                                                 AioContext *ctx,
 196                                                 IOHandler *io_read,
 197                                                 IOHandler *io_write,
 198                                                 void *opaque)
 199 {
 200     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 201     aio_set_fd_handler(ctx, fioc->fd, false, io_read, io_write,
 202                        NULL, NULL, opaque);
 203 }
 204
 205 static GSource *qio_channel_file_create_watch(QIOChannel *ioc,
 206                                               GIOCondition condition)
 207 {
 208     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 209     return qio_channel_create_fd_watch(ioc,
 210                                        fioc->fd,
 211                                        condition);
 212 }
 213
 214 static void qio_channel_file_class_init(ObjectClass *klass,
 215                                         void *class_data G_GNUC_UNUSED)
 216 {
 217     QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
 218
 219     ioc_klass->io_writev = qio_channel_file_writev;
 220     ioc_klass->io_readv = qio_channel_file_readv;
 221     ioc_klass->io_set_blocking = qio_channel_file_set_blocking;
 222     ioc_klass->io_seek = qio_channel_file_seek;
 223     ioc_klass->io_close = qio_channel_file_close;
 224     ioc_klass->io_create_watch = qio_channel_file_create_watch;
 225     ioc_klass->io_set_aio_fd_handler = qio_channel_file_set_aio_fd_handler;
 226 }
 227
 228 static const TypeInfo qio_channel_file_info = {
 229     .parent = TYPE_QIO_CHANNEL,
 230     .name = TYPE_QIO_CHANNEL_FILE,
 231     .instance_size = sizeof(QIOChannelFile),
 232     .instance_init = qio_channel_file_init,
 233     .instance_finalize = qio_channel_file_finalize,
 234     .class_init = qio_channel_file_class_init,
 235 };
 236
 237 static void qio_channel_file_register_types(void)
 238 {
 239     type_register_static(&qio_channel_file_info);
 240 }
 241
 242 type_init(qio_channel_file_register_types);