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 *
qio_channel_file_new_fd(int fd)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 *
qio_channel_file_new_path(const char * path,int flags,mode_t mode,Error ** errp)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
qio_channel_file_init(Object * obj)69 static void qio_channel_file_init(Object *obj)
70 {
71 QIOChannelFile *ioc = QIO_CHANNEL_FILE(obj);
72 ioc->fd = -1;
73 }
74
qio_channel_file_finalize(Object * obj)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
qio_channel_file_readv(QIOChannel * ioc,const struct iovec * iov,size_t niov,int ** fds,size_t * nfds,int flags,Error ** errp)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
qio_channel_file_writev(QIOChannel * ioc,const struct iovec * iov,size_t niov,int * fds,size_t nfds,int flags,Error ** errp)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
qio_channel_file_set_blocking(QIOChannel * ioc,bool enabled,Error ** errp)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
qio_channel_file_seek(QIOChannel * ioc,off_t offset,int whence,Error ** errp)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
qio_channel_file_close(QIOChannel * ioc,Error ** errp)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
qio_channel_file_set_aio_fd_handler(QIOChannel * ioc,AioContext * read_ctx,IOHandler * io_read,AioContext * write_ctx,IOHandler * io_write,void * opaque)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
qio_channel_file_create_watch(QIOChannel * ioc,GIOCondition condition)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
qio_channel_file_class_init(ObjectClass * klass,void * class_data G_GNUC_UNUSED)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
qio_channel_file_register_types(void)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);
247