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 "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(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 | Error **errp) |
118 | { |
119 | QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc); |
120 | ssize_t ret; |
121 | |
122 | retry: |
123 | ret = writev(fioc->fd, iov, niov); |
124 | if (ret <= 0) { |
125 | if (errno == EAGAIN) { |
126 | return QIO_CHANNEL_ERR_BLOCK; |
127 | } |
128 | if (errno == EINTR) { |
129 | goto retry; |
130 | } |
131 | error_setg_errno(errp, errno, |
132 | "Unable to write to file" ); |
133 | return -1; |
134 | } |
135 | return ret; |
136 | } |
137 | |
138 | static int qio_channel_file_set_blocking(QIOChannel *ioc, |
139 | bool enabled, |
140 | Error **errp) |
141 | { |
142 | QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc); |
143 | |
144 | if (enabled) { |
145 | qemu_set_block(fioc->fd); |
146 | } else { |
147 | qemu_set_nonblock(fioc->fd); |
148 | } |
149 | return 0; |
150 | } |
151 | |
152 | |
153 | static off_t qio_channel_file_seek(QIOChannel *ioc, |
154 | off_t offset, |
155 | int whence, |
156 | Error **errp) |
157 | { |
158 | QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc); |
159 | off_t ret; |
160 | |
161 | ret = lseek(fioc->fd, offset, whence); |
162 | if (ret == (off_t)-1) { |
163 | error_setg_errno(errp, errno, |
164 | "Unable to seek to offset %lld whence %d in file" , |
165 | (long long int)offset, whence); |
166 | return -1; |
167 | } |
168 | return ret; |
169 | } |
170 | |
171 | |
172 | static int qio_channel_file_close(QIOChannel *ioc, |
173 | Error **errp) |
174 | { |
175 | QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc); |
176 | |
177 | if (qemu_close(fioc->fd) < 0) { |
178 | error_setg_errno(errp, errno, |
179 | "Unable to close file" ); |
180 | return -1; |
181 | } |
182 | fioc->fd = -1; |
183 | return 0; |
184 | } |
185 | |
186 | |
187 | static void qio_channel_file_set_aio_fd_handler(QIOChannel *ioc, |
188 | AioContext *ctx, |
189 | IOHandler *io_read, |
190 | IOHandler *io_write, |
191 | void *opaque) |
192 | { |
193 | QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc); |
194 | aio_set_fd_handler(ctx, fioc->fd, false, io_read, io_write, NULL, opaque); |
195 | } |
196 | |
197 | static GSource *qio_channel_file_create_watch(QIOChannel *ioc, |
198 | GIOCondition condition) |
199 | { |
200 | QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc); |
201 | return qio_channel_create_fd_watch(ioc, |
202 | fioc->fd, |
203 | condition); |
204 | } |
205 | |
206 | static void qio_channel_file_class_init(ObjectClass *klass, |
207 | void *class_data G_GNUC_UNUSED) |
208 | { |
209 | QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass); |
210 | |
211 | ioc_klass->io_writev = qio_channel_file_writev; |
212 | ioc_klass->io_readv = qio_channel_file_readv; |
213 | ioc_klass->io_set_blocking = qio_channel_file_set_blocking; |
214 | ioc_klass->io_seek = qio_channel_file_seek; |
215 | ioc_klass->io_close = qio_channel_file_close; |
216 | ioc_klass->io_create_watch = qio_channel_file_create_watch; |
217 | ioc_klass->io_set_aio_fd_handler = qio_channel_file_set_aio_fd_handler; |
218 | } |
219 | |
220 | static const TypeInfo qio_channel_file_info = { |
221 | .parent = TYPE_QIO_CHANNEL, |
222 | .name = TYPE_QIO_CHANNEL_FILE, |
223 | .instance_size = sizeof(QIOChannelFile), |
224 | .instance_init = qio_channel_file_init, |
225 | .instance_finalize = qio_channel_file_finalize, |
226 | .class_init = qio_channel_file_class_init, |
227 | }; |
228 | |
229 | static void qio_channel_file_register_types(void) |
230 | { |
231 | type_register_static(&qio_channel_file_info); |
232 | } |
233 | |
234 | type_init(qio_channel_file_register_types); |
235 | |