Merge tag 'pull-la-20220704' of https://gitlab.com/rth7680/qemu into staging
[qemu.git] / 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 Error **errp)
90 {
91 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
92 ssize_t ret;
93
94 retry:
95 ret = readv(fioc->fd, iov, niov);
96 if (ret < 0) {
97 if (errno == EAGAIN) {
98 return QIO_CHANNEL_ERR_BLOCK;
99 }
100 if (errno == EINTR) {
101 goto retry;
102 }
103
104 error_setg_errno(errp, errno,
105 "Unable to read from file");
106 return -1;
107 }
108
109 return ret;
110 }
111
112 static ssize_t qio_channel_file_writev(QIOChannel *ioc,
113 const struct iovec *iov,
114 size_t niov,
115 int *fds,
116 size_t nfds,
117 int flags,
118 Error **errp)
119 {
120 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
121 ssize_t ret;
122
123 retry:
124 ret = writev(fioc->fd, iov, niov);
125 if (ret <= 0) {
126 if (errno == EAGAIN) {
127 return QIO_CHANNEL_ERR_BLOCK;
128 }
129 if (errno == EINTR) {
130 goto retry;
131 }
132 error_setg_errno(errp, errno,
133 "Unable to write to file");
134 return -1;
135 }
136 return ret;
137 }
138
139 static int qio_channel_file_set_blocking(QIOChannel *ioc,
140 bool enabled,
141 Error **errp)
142 {
143 #ifdef WIN32
144 /* not implemented */
145 error_setg_errno(errp, errno, "Failed to set FD nonblocking");
146 return -1;
147 #else
148 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
149
150 if (!g_unix_set_fd_nonblocking(fioc->fd, !enabled, NULL)) {
151 error_setg_errno(errp, errno, "Failed to set FD nonblocking");
152 return -1;
153 }
154 return 0;
155 #endif
156 }
157
158
159 static off_t qio_channel_file_seek(QIOChannel *ioc,
160 off_t offset,
161 int whence,
162 Error **errp)
163 {
164 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
165 off_t ret;
166
167 ret = lseek(fioc->fd, offset, whence);
168 if (ret == (off_t)-1) {
169 error_setg_errno(errp, errno,
170 "Unable to seek to offset %lld whence %d in file",
171 (long long int)offset, whence);
172 return -1;
173 }
174 return ret;
175 }
176
177
178 static int qio_channel_file_close(QIOChannel *ioc,
179 Error **errp)
180 {
181 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
182
183 if (qemu_close(fioc->fd) < 0) {
184 error_setg_errno(errp, errno,
185 "Unable to close file");
186 return -1;
187 }
188 fioc->fd = -1;
189 return 0;
190 }
191
192
193 static void qio_channel_file_set_aio_fd_handler(QIOChannel *ioc,
194 AioContext *ctx,
195 IOHandler *io_read,
196 IOHandler *io_write,
197 void *opaque)
198 {
199 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
200 aio_set_fd_handler(ctx, fioc->fd, false, io_read, io_write,
201 NULL, NULL, opaque);
202 }
203
204 static GSource *qio_channel_file_create_watch(QIOChannel *ioc,
205 GIOCondition condition)
206 {
207 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
208 return qio_channel_create_fd_watch(ioc,
209 fioc->fd,
210 condition);
211 }
212
213 static void qio_channel_file_class_init(ObjectClass *klass,
214 void *class_data G_GNUC_UNUSED)
215 {
216 QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
217
218 ioc_klass->io_writev = qio_channel_file_writev;
219 ioc_klass->io_readv = qio_channel_file_readv;
220 ioc_klass->io_set_blocking = qio_channel_file_set_blocking;
221 ioc_klass->io_seek = qio_channel_file_seek;
222 ioc_klass->io_close = qio_channel_file_close;
223 ioc_klass->io_create_watch = qio_channel_file_create_watch;
224 ioc_klass->io_set_aio_fd_handler = qio_channel_file_set_aio_fd_handler;
225 }
226
227 static const TypeInfo qio_channel_file_info = {
228 .parent = TYPE_QIO_CHANNEL,
229 .name = TYPE_QIO_CHANNEL_FILE,
230 .instance_size = sizeof(QIOChannelFile),
231 .instance_init = qio_channel_file_init,
232 .instance_finalize = qio_channel_file_finalize,
233 .class_init = qio_channel_file_class_init,
234 };
235
236 static void qio_channel_file_register_types(void)
237 {
238 type_register_static(&qio_channel_file_info);
239 }
240
241 type_init(qio_channel_file_register_types);