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     if (lseek(fd, 0, SEEK_CUR) != (off_t)-1) {
  40         qio_channel_set_feature(QIO_CHANNEL(ioc), QIO_CHANNEL_FEATURE_SEEKABLE);
  41     }
  42
  43     trace_qio_channel_file_new_fd(ioc, fd);
  44
  45     return ioc;
  46 }
  47
  48 QIOChannelFile *
  49 qio_channel_file_new_dupfd(int fd, Error **errp)
  50 {
  51     int newfd = dup(fd);
  52
  53     if (newfd < 0) {
  54         error_setg_errno(errp, errno, "Could not dup FD %d", fd);
  55         return NULL;
  56     }
  57
  58     return qio_channel_file_new_fd(newfd);
  59 }
  60
  61 QIOChannelFile *
  62 qio_channel_file_new_path(const char *path,
  63                           int flags,
  64                           mode_t mode,
  65                           Error **errp)
  66 {
  67     QIOChannelFile *ioc;
  68
  69     ioc = QIO_CHANNEL_FILE(object_new(TYPE_QIO_CHANNEL_FILE));
  70
  71     ioc->fd = qemu_open_old(path, flags, mode);
  72     if (ioc->fd < 0) {
  73         object_unref(OBJECT(ioc));
  74         error_setg_errno(errp, errno,
  75                          "Unable to open %s", path);
  76         return NULL;
  77     }
  78
  79     if (lseek(ioc->fd, 0, SEEK_CUR) != (off_t)-1) {
  80         qio_channel_set_feature(QIO_CHANNEL(ioc), QIO_CHANNEL_FEATURE_SEEKABLE);
  81     }
  82
  83     trace_qio_channel_file_new_path(ioc, path, flags, mode, ioc->fd);
  84
  85     return ioc;
  86 }
  87
  88
  89 static void qio_channel_file_init(Object *obj)
  90 {
  91     QIOChannelFile *ioc = QIO_CHANNEL_FILE(obj);
  92     ioc->fd = -1;
  93 }
  94
  95 static void qio_channel_file_finalize(Object *obj)
  96 {
  97     QIOChannelFile *ioc = QIO_CHANNEL_FILE(obj);
  98     if (ioc->fd != -1) {
  99         qemu_close(ioc->fd);
 100         ioc->fd = -1;
 101     }
 102 }
 103
 104
 105 static ssize_t qio_channel_file_readv(QIOChannel *ioc,
 106                                       const struct iovec *iov,
 107                                       size_t niov,
 108                                       int **fds,
 109                                       size_t *nfds,
 110                                       int flags,
 111                                       Error **errp)
 112 {
 113     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 114     ssize_t ret;
 115
 116  retry:
 117     ret = readv(fioc->fd, iov, niov);
 118     if (ret < 0) {
 119         if (errno == EAGAIN) {
 120             return QIO_CHANNEL_ERR_BLOCK;
 121         }
 122         if (errno == EINTR) {
 123             goto retry;
 124         }
 125
 126         error_setg_errno(errp, errno,
 127                          "Unable to read from file");
 128         return -1;
 129     }
 130
 131     return ret;
 132 }
 133
 134 static ssize_t qio_channel_file_writev(QIOChannel *ioc,
 135                                        const struct iovec *iov,
 136                                        size_t niov,
 137                                        int *fds,
 138                                        size_t nfds,
 139                                        int flags,
 140                                        Error **errp)
 141 {
 142     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 143     ssize_t ret;
 144
 145  retry:
 146     ret = writev(fioc->fd, iov, niov);
 147     if (ret <= 0) {
 148         if (errno == EAGAIN) {
 149             return QIO_CHANNEL_ERR_BLOCK;
 150         }
 151         if (errno == EINTR) {
 152             goto retry;
 153         }
 154         error_setg_errno(errp, errno,
 155                          "Unable to write to file");
 156         return -1;
 157     }
 158     return ret;
 159 }
 160
 161 #ifdef CONFIG_PREADV
 162 static ssize_t qio_channel_file_preadv(QIOChannel *ioc,
 163                                        const struct iovec *iov,
 164                                        size_t niov,
 165                                        off_t offset,
 166                                        Error **errp)
 167 {
 168     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 169     ssize_t ret;
 170
 171  retry:
 172     ret = preadv(fioc->fd, iov, niov, offset);
 173     if (ret < 0) {
 174         if (errno == EAGAIN) {
 175             return QIO_CHANNEL_ERR_BLOCK;
 176         }
 177         if (errno == EINTR) {
 178             goto retry;
 179         }
 180
 181         error_setg_errno(errp, errno, "Unable to read from file");
 182         return -1;
 183     }
 184
 185     return ret;
 186 }
 187
 188 static ssize_t qio_channel_file_pwritev(QIOChannel *ioc,
 189                                         const struct iovec *iov,
 190                                         size_t niov,
 191                                         off_t offset,
 192                                         Error **errp)
 193 {
 194     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 195     ssize_t ret;
 196
 197  retry:
 198     ret = pwritev(fioc->fd, iov, niov, offset);
 199     if (ret <= 0) {
 200         if (errno == EAGAIN) {
 201             return QIO_CHANNEL_ERR_BLOCK;
 202         }
 203         if (errno == EINTR) {
 204             goto retry;
 205         }
 206         error_setg_errno(errp, errno, "Unable to write to file");
 207         return -1;
 208     }
 209     return ret;
 210 }
 211 #endif /* CONFIG_PREADV */
 212
 213 static int qio_channel_file_set_blocking(QIOChannel *ioc,
 214                                          bool enabled,
 215                                          Error **errp)
 216 {
 217 #ifdef WIN32
 218     /* not implemented */
 219     error_setg_errno(errp, errno, "Failed to set FD nonblocking");
 220     return -1;
 221 #else
 222     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 223
 224     if (!g_unix_set_fd_nonblocking(fioc->fd, !enabled, NULL)) {
 225         error_setg_errno(errp, errno, "Failed to set FD nonblocking");
 226         return -1;
 227     }
 228     return 0;
 229 #endif
 230 }
 231
 232
 233 static off_t qio_channel_file_seek(QIOChannel *ioc,
 234                                    off_t offset,
 235                                    int whence,
 236                                    Error **errp)
 237 {
 238     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 239     off_t ret;
 240
 241     ret = lseek(fioc->fd, offset, whence);
 242     if (ret == (off_t)-1) {
 243         error_setg_errno(errp, errno,
 244                          "Unable to seek to offset %lld whence %d in file",
 245                          (long long int)offset, whence);
 246         return -1;
 247     }
 248     return ret;
 249 }
 250
 251
 252 static int qio_channel_file_close(QIOChannel *ioc,
 253                                   Error **errp)
 254 {
 255     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 256
 257     if (qemu_close(fioc->fd) < 0) {
 258         error_setg_errno(errp, errno,
 259                          "Unable to close file");
 260         return -1;
 261     }
 262     fioc->fd = -1;
 263     return 0;
 264 }
 265
 266
 267 static void qio_channel_file_set_aio_fd_handler(QIOChannel *ioc,
 268                                                 AioContext *read_ctx,
 269                                                 IOHandler *io_read,
 270                                                 AioContext *write_ctx,
 271                                                 IOHandler *io_write,
 272                                                 void *opaque)
 273 {
 274     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 275
 276     qio_channel_util_set_aio_fd_handler(fioc->fd, read_ctx, io_read,
 277                                         fioc->fd, write_ctx, io_write,
 278                                         opaque);
 279 }
 280
 281 static GSource *qio_channel_file_create_watch(QIOChannel *ioc,
 282                                               GIOCondition condition)
 283 {
 284     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 285     return qio_channel_create_fd_watch(ioc,
 286                                        fioc->fd,
 287                                        condition);
 288 }
 289
 290 static void qio_channel_file_class_init(ObjectClass *klass,
 291                                         void *class_data G_GNUC_UNUSED)
 292 {
 293     QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
 294
 295     ioc_klass->io_writev = qio_channel_file_writev;
 296     ioc_klass->io_readv = qio_channel_file_readv;
 297     ioc_klass->io_set_blocking = qio_channel_file_set_blocking;
 298 #ifdef CONFIG_PREADV
 299     ioc_klass->io_pwritev = qio_channel_file_pwritev;
 300     ioc_klass->io_preadv = qio_channel_file_preadv;
 301 #endif
 302     ioc_klass->io_seek = qio_channel_file_seek;
 303     ioc_klass->io_close = qio_channel_file_close;
 304     ioc_klass->io_create_watch = qio_channel_file_create_watch;
 305     ioc_klass->io_set_aio_fd_handler = qio_channel_file_set_aio_fd_handler;
 306 }
 307
 308 static const TypeInfo qio_channel_file_info = {
 309     .parent = TYPE_QIO_CHANNEL,
 310     .name = TYPE_QIO_CHANNEL_FILE,
 311     .instance_size = sizeof(QIOChannelFile),
 312     .instance_init = qio_channel_file_init,
 313     .instance_finalize = qio_channel_file_finalize,
 314     .class_init = qio_channel_file_class_init,
 315 };
 316
 317 static void qio_channel_file_register_types(void)
 318 {
 319     type_register_static(&qio_channel_file_info);
 320 }
 321
 322 type_init(qio_channel_file_register_types);