pc: acpi: create Processor and Notify objects only for valid lapics
[qemu/ar7.git] / io / channel-file.c
blob19a432562a971438e34bafaf894a221a20464fbc
1 /*
2 * QEMU I/O channels files driver
4 * Copyright (c) 2015 Red Hat, Inc.
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.
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.
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/>.
21 #include "qemu/osdep.h"
22 #include "io/channel-file.h"
23 #include "io/channel-watch.h"
24 #include "qemu/sockets.h"
25 #include "trace.h"
27 QIOChannelFile *
28 qio_channel_file_new_fd(int fd)
30 QIOChannelFile *ioc;
32 ioc = QIO_CHANNEL_FILE(object_new(TYPE_QIO_CHANNEL_FILE));
34 ioc->fd = fd;
36 trace_qio_channel_file_new_fd(ioc, fd);
38 return ioc;
42 QIOChannelFile *
43 qio_channel_file_new_path(const char *path,
44 int flags,
45 mode_t mode,
46 Error **errp)
48 QIOChannelFile *ioc;
50 ioc = QIO_CHANNEL_FILE(object_new(TYPE_QIO_CHANNEL_FILE));
52 if (flags & O_WRONLY) {
53 ioc->fd = open(path, flags, mode);
54 } else {
55 ioc->fd = open(path, flags);
57 if (ioc->fd < 0) {
58 object_unref(OBJECT(ioc));
59 error_setg_errno(errp, errno,
60 "Unable to open %s", path);
61 return NULL;
64 trace_qio_channel_file_new_path(ioc, path, flags, mode, ioc->fd);
66 return ioc;
70 static void qio_channel_file_init(Object *obj)
72 QIOChannelFile *ioc = QIO_CHANNEL_FILE(obj);
73 ioc->fd = -1;
76 static void qio_channel_file_finalize(Object *obj)
78 QIOChannelFile *ioc = QIO_CHANNEL_FILE(obj);
79 if (ioc->fd != -1) {
80 close(ioc->fd);
81 ioc->fd = -1;
86 static ssize_t qio_channel_file_readv(QIOChannel *ioc,
87 const struct iovec *iov,
88 size_t niov,
89 int **fds,
90 size_t *nfds,
91 Error **errp)
93 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
94 ssize_t ret;
96 retry:
97 ret = readv(fioc->fd, iov, niov);
98 if (ret < 0) {
99 if (errno == EAGAIN ||
100 errno == EWOULDBLOCK) {
101 return QIO_CHANNEL_ERR_BLOCK;
103 if (errno == EINTR) {
104 goto retry;
107 error_setg_errno(errp, errno,
108 "Unable to read from file");
109 return -1;
112 return ret;
115 static ssize_t qio_channel_file_writev(QIOChannel *ioc,
116 const struct iovec *iov,
117 size_t niov,
118 int *fds,
119 size_t nfds,
120 Error **errp)
122 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
123 ssize_t ret;
125 retry:
126 ret = writev(fioc->fd, iov, niov);
127 if (ret <= 0) {
128 if (errno == EAGAIN ||
129 errno == EWOULDBLOCK) {
130 return QIO_CHANNEL_ERR_BLOCK;
132 if (errno == EINTR) {
133 goto retry;
135 error_setg_errno(errp, errno,
136 "Unable to write to file");
137 return -1;
139 return ret;
142 static int qio_channel_file_set_blocking(QIOChannel *ioc,
143 bool enabled,
144 Error **errp)
146 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
148 if (enabled) {
149 qemu_set_block(fioc->fd);
150 } else {
151 qemu_set_nonblock(fioc->fd);
153 return 0;
157 static off_t qio_channel_file_seek(QIOChannel *ioc,
158 off_t offset,
159 int whence,
160 Error **errp)
162 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
163 off_t ret;
165 ret = lseek(fioc->fd, offset, whence);
166 if (ret == (off_t)-1) {
167 error_setg_errno(errp, errno,
168 "Unable to seek to offset %lld whence %d in file",
169 (long long int)offset, whence);
170 return -1;
172 return ret;
176 static int qio_channel_file_close(QIOChannel *ioc,
177 Error **errp)
179 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
181 if (close(fioc->fd) < 0) {
182 error_setg_errno(errp, errno,
183 "Unable to close file");
184 return -1;
186 return 0;
190 static GSource *qio_channel_file_create_watch(QIOChannel *ioc,
191 GIOCondition condition)
193 QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
194 return qio_channel_create_fd_watch(ioc,
195 fioc->fd,
196 condition);
199 static void qio_channel_file_class_init(ObjectClass *klass,
200 void *class_data G_GNUC_UNUSED)
202 QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
204 ioc_klass->io_writev = qio_channel_file_writev;
205 ioc_klass->io_readv = qio_channel_file_readv;
206 ioc_klass->io_set_blocking = qio_channel_file_set_blocking;
207 ioc_klass->io_seek = qio_channel_file_seek;
208 ioc_klass->io_close = qio_channel_file_close;
209 ioc_klass->io_create_watch = qio_channel_file_create_watch;
212 static const TypeInfo qio_channel_file_info = {
213 .parent = TYPE_QIO_CHANNEL,
214 .name = TYPE_QIO_CHANNEL_FILE,
215 .instance_size = sizeof(QIOChannelFile),
216 .instance_init = qio_channel_file_init,
217 .instance_finalize = qio_channel_file_finalize,
218 .class_init = qio_channel_file_class_init,
221 static void qio_channel_file_register_types(void)
223 type_register_static(&qio_channel_file_info);
226 type_init(qio_channel_file_register_types);