4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
25 #include "qapi/error.h"
26 #include "qemu-common.h"
27 #include "chardev/char.h"
28 #include "io/channel-file.h"
29 #include "qemu/sockets.h"
30 #include "qemu/error-report.h"
32 #include "chardev/char-io.h"
39 /* Protected by the Chardev chr_write_lock. */
45 #define PTY_CHARDEV(obj) OBJECT_CHECK(PtyChardev, (obj), TYPE_CHARDEV_PTY)
47 static void pty_chr_update_read_handler_locked(Chardev
*chr
);
48 static void pty_chr_state(Chardev
*chr
, int connected
);
50 static void pty_chr_timer_cancel(PtyChardev
*s
)
53 g_source_destroy(s
->timer_src
);
54 g_source_unref(s
->timer_src
);
59 static void pty_chr_open_src_cancel(PtyChardev
*s
)
62 g_source_destroy(s
->open_source
);
63 g_source_unref(s
->open_source
);
64 s
->open_source
= NULL
;
68 static gboolean
pty_chr_timer(gpointer opaque
)
70 struct Chardev
*chr
= CHARDEV(opaque
);
71 PtyChardev
*s
= PTY_CHARDEV(opaque
);
73 qemu_mutex_lock(&chr
->chr_write_lock
);
74 pty_chr_timer_cancel(s
);
75 pty_chr_open_src_cancel(s
);
78 pty_chr_update_read_handler_locked(chr
);
80 qemu_mutex_unlock(&chr
->chr_write_lock
);
84 /* Called with chr_write_lock held. */
85 static void pty_chr_rearm_timer(Chardev
*chr
, int ms
)
87 PtyChardev
*s
= PTY_CHARDEV(chr
);
90 pty_chr_timer_cancel(s
);
91 name
= g_strdup_printf("pty-timer-%s", chr
->label
);
92 s
->timer_src
= qemu_chr_timeout_add_ms(chr
, ms
, pty_chr_timer
, chr
);
93 g_source_set_name(s
->timer_src
, name
);
97 /* Called with chr_write_lock held. */
98 static void pty_chr_update_read_handler_locked(Chardev
*chr
)
100 PtyChardev
*s
= PTY_CHARDEV(chr
);
103 QIOChannelFile
*fioc
= QIO_CHANNEL_FILE(s
->ioc
);
106 pfd
.events
= G_IO_OUT
;
109 rc
= g_poll(&pfd
, 1, 0);
110 } while (rc
== -1 && errno
== EINTR
);
113 if (pfd
.revents
& G_IO_HUP
) {
114 pty_chr_state(chr
, 0);
116 pty_chr_state(chr
, 1);
120 static void pty_chr_update_read_handler(Chardev
*chr
)
122 qemu_mutex_lock(&chr
->chr_write_lock
);
123 pty_chr_update_read_handler_locked(chr
);
124 qemu_mutex_unlock(&chr
->chr_write_lock
);
127 /* Called with chr_write_lock held. */
128 static int char_pty_chr_write(Chardev
*chr
, const uint8_t *buf
, int len
)
130 PtyChardev
*s
= PTY_CHARDEV(chr
);
135 return io_channel_send(s
->ioc
, buf
, len
);
138 static GSource
*pty_chr_add_watch(Chardev
*chr
, GIOCondition cond
)
140 PtyChardev
*s
= PTY_CHARDEV(chr
);
144 return qio_channel_create_watch(s
->ioc
, cond
);
147 static int pty_chr_read_poll(void *opaque
)
149 Chardev
*chr
= CHARDEV(opaque
);
150 PtyChardev
*s
= PTY_CHARDEV(opaque
);
152 s
->read_bytes
= qemu_chr_be_can_write(chr
);
153 return s
->read_bytes
;
156 static gboolean
pty_chr_read(QIOChannel
*chan
, GIOCondition cond
, void *opaque
)
158 Chardev
*chr
= CHARDEV(opaque
);
159 PtyChardev
*s
= PTY_CHARDEV(opaque
);
161 uint8_t buf
[CHR_READ_BUF_LEN
];
165 if (len
> s
->read_bytes
) {
171 ret
= qio_channel_read(s
->ioc
, (char *)buf
, len
, NULL
);
173 pty_chr_state(chr
, 0);
176 pty_chr_state(chr
, 1);
177 qemu_chr_be_write(chr
, buf
, ret
);
182 static gboolean
qemu_chr_be_generic_open_func(gpointer opaque
)
184 Chardev
*chr
= CHARDEV(opaque
);
185 PtyChardev
*s
= PTY_CHARDEV(opaque
);
187 s
->open_source
= NULL
;
188 qemu_chr_be_event(chr
, CHR_EVENT_OPENED
);
192 /* Called with chr_write_lock held. */
193 static void pty_chr_state(Chardev
*chr
, int connected
)
195 PtyChardev
*s
= PTY_CHARDEV(chr
);
198 pty_chr_open_src_cancel(s
);
199 remove_fd_in_watch(chr
);
201 /* (re-)connect poll interval for idle guests: once per second.
202 * We check more frequently in case the guests sends data to
203 * the virtual device linked to our pty. */
204 pty_chr_rearm_timer(chr
, 1000);
206 pty_chr_timer_cancel(s
);
208 g_assert(s
->open_source
== NULL
);
209 s
->open_source
= g_idle_source_new();
211 g_source_set_callback(s
->open_source
,
212 qemu_chr_be_generic_open_func
,
214 g_source_attach(s
->open_source
, chr
->gcontext
);
217 chr
->gsource
= io_add_watch_poll(chr
, s
->ioc
,
225 static void char_pty_finalize(Object
*obj
)
227 Chardev
*chr
= CHARDEV(obj
);
228 PtyChardev
*s
= PTY_CHARDEV(obj
);
230 qemu_mutex_lock(&chr
->chr_write_lock
);
231 pty_chr_state(chr
, 0);
232 object_unref(OBJECT(s
->ioc
));
233 pty_chr_timer_cancel(s
);
234 qemu_mutex_unlock(&chr
->chr_write_lock
);
235 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
238 static void char_pty_open(Chardev
*chr
,
239 ChardevBackend
*backend
,
244 int master_fd
, slave_fd
;
245 char pty_name
[PATH_MAX
];
248 master_fd
= qemu_openpty_raw(&slave_fd
, pty_name
);
250 error_setg_errno(errp
, errno
, "Failed to create PTY");
255 qemu_set_nonblock(master_fd
);
257 chr
->filename
= g_strdup_printf("pty:%s", pty_name
);
258 error_printf("char device redirected to %s (label %s)\n",
259 pty_name
, chr
->label
);
261 s
= PTY_CHARDEV(chr
);
262 s
->ioc
= QIO_CHANNEL(qio_channel_file_new_fd(master_fd
));
263 name
= g_strdup_printf("chardev-pty-%s", chr
->label
);
264 qio_channel_set_name(QIO_CHANNEL(s
->ioc
), name
);
270 static void char_pty_class_init(ObjectClass
*oc
, void *data
)
272 ChardevClass
*cc
= CHARDEV_CLASS(oc
);
274 cc
->open
= char_pty_open
;
275 cc
->chr_write
= char_pty_chr_write
;
276 cc
->chr_update_read_handler
= pty_chr_update_read_handler
;
277 cc
->chr_add_watch
= pty_chr_add_watch
;
280 static const TypeInfo char_pty_type_info
= {
281 .name
= TYPE_CHARDEV_PTY
,
282 .parent
= TYPE_CHARDEV
,
283 .instance_size
= sizeof(PtyChardev
),
284 .instance_finalize
= char_pty_finalize
,
285 .class_init
= char_pty_class_init
,
288 static void register_types(void)
290 type_register_static(&char_pty_type_info
);
293 type_init(register_types
);