Revision 909cda12
| b/console.c | ||
|---|---|---|
| 1123 | 1123 |
int len; |
| 1124 | 1124 |
uint8_t buf[16]; |
| 1125 | 1125 |
|
| 1126 |
len = qemu_chr_can_read(s->chr);
|
|
| 1126 |
len = qemu_chr_be_can_write(s->chr);
|
|
| 1127 | 1127 |
if (len > s->out_fifo.count) |
| 1128 | 1128 |
len = s->out_fifo.count; |
| 1129 | 1129 |
if (len > 0) {
|
| b/hw/baum.c | ||
|---|---|---|
| 223 | 223 |
|
| 224 | 224 |
if (!baum->out_buf_used) |
| 225 | 225 |
return; |
| 226 |
room = qemu_chr_can_read(chr);
|
|
| 226 |
room = qemu_chr_be_can_write(chr);
|
|
| 227 | 227 |
if (!room) |
| 228 | 228 |
return; |
| 229 | 229 |
if (room > baum->out_buf_used) |
| ... | ... | |
| 250 | 250 |
while (len--) |
| 251 | 251 |
if ((*cur++ = *buf++) == ESC) |
| 252 | 252 |
*cur++ = ESC; |
| 253 |
room = qemu_chr_can_read(baum->chr);
|
|
| 253 |
room = qemu_chr_be_can_write(baum->chr);
|
|
| 254 | 254 |
len = cur - io_buf; |
| 255 | 255 |
if (len <= room) {
|
| 256 | 256 |
/* Fits */ |
| b/qemu-char.c | ||
|---|---|---|
| 151 | 151 |
return s->chr_ioctl(s, cmd, arg); |
| 152 | 152 |
} |
| 153 | 153 |
|
| 154 |
int qemu_chr_can_read(CharDriverState *s)
|
|
| 154 |
int qemu_chr_be_can_write(CharDriverState *s)
|
|
| 155 | 155 |
{
|
| 156 | 156 |
if (!s->chr_can_read) |
| 157 | 157 |
return 0; |
| ... | ... | |
| 565 | 565 |
CharDriverState *chr = opaque; |
| 566 | 566 |
FDCharDriver *s = chr->opaque; |
| 567 | 567 |
|
| 568 |
s->max_size = qemu_chr_can_read(chr);
|
|
| 568 |
s->max_size = qemu_chr_be_can_write(chr);
|
|
| 569 | 569 |
return s->max_size; |
| 570 | 570 |
} |
| 571 | 571 |
|
| ... | ... | |
| 699 | 699 |
CharDriverState *chr = opaque; |
| 700 | 700 |
|
| 701 | 701 |
/* try to flush the queue if needed */ |
| 702 |
if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
|
|
| 702 |
if (term_fifo_size != 0 && qemu_chr_be_can_write(chr) > 0) {
|
|
| 703 | 703 |
qemu_chr_be_write(chr, term_fifo, 1); |
| 704 | 704 |
term_fifo_size = 0; |
| 705 | 705 |
} |
| ... | ... | |
| 724 | 724 |
return; |
| 725 | 725 |
} |
| 726 | 726 |
if (size > 0) {
|
| 727 |
if (qemu_chr_can_read(chr) > 0) {
|
|
| 727 |
if (qemu_chr_be_can_write(chr) > 0) {
|
|
| 728 | 728 |
qemu_chr_be_write(chr, buf, 1); |
| 729 | 729 |
} else if (term_fifo_size == 0) {
|
| 730 | 730 |
term_fifo[term_fifo_size++] = buf[0]; |
| ... | ... | |
| 890 | 890 |
CharDriverState *chr = opaque; |
| 891 | 891 |
PtyCharDriver *s = chr->opaque; |
| 892 | 892 |
|
| 893 |
s->read_bytes = qemu_chr_can_read(chr);
|
|
| 893 |
s->read_bytes = qemu_chr_be_can_write(chr);
|
|
| 894 | 894 |
return s->read_bytes; |
| 895 | 895 |
} |
| 896 | 896 |
|
| ... | ... | |
| 1602 | 1602 |
{
|
| 1603 | 1603 |
WinCharState *s = chr->opaque; |
| 1604 | 1604 |
|
| 1605 |
s->max_size = qemu_chr_can_read(chr);
|
|
| 1605 |
s->max_size = qemu_chr_be_can_write(chr);
|
|
| 1606 | 1606 |
return s->max_size; |
| 1607 | 1607 |
} |
| 1608 | 1608 |
|
| ... | ... | |
| 1840 | 1840 |
CharDriverState *chr = opaque; |
| 1841 | 1841 |
NetCharDriver *s = chr->opaque; |
| 1842 | 1842 |
|
| 1843 |
s->max_size = qemu_chr_can_read(chr);
|
|
| 1843 |
s->max_size = qemu_chr_be_can_write(chr);
|
|
| 1844 | 1844 |
|
| 1845 | 1845 |
/* If there were any stray characters in the queue process them |
| 1846 | 1846 |
* first |
| ... | ... | |
| 1848 | 1848 |
while (s->max_size > 0 && s->bufptr < s->bufcnt) {
|
| 1849 | 1849 |
qemu_chr_be_write(chr, &s->buf[s->bufptr], 1); |
| 1850 | 1850 |
s->bufptr++; |
| 1851 |
s->max_size = qemu_chr_can_read(chr);
|
|
| 1851 |
s->max_size = qemu_chr_be_can_write(chr);
|
|
| 1852 | 1852 |
} |
| 1853 | 1853 |
return s->max_size; |
| 1854 | 1854 |
} |
| ... | ... | |
| 1869 | 1869 |
while (s->max_size > 0 && s->bufptr < s->bufcnt) {
|
| 1870 | 1870 |
qemu_chr_be_write(chr, &s->buf[s->bufptr], 1); |
| 1871 | 1871 |
s->bufptr++; |
| 1872 |
s->max_size = qemu_chr_can_read(chr);
|
|
| 1872 |
s->max_size = qemu_chr_be_can_write(chr);
|
|
| 1873 | 1873 |
} |
| 1874 | 1874 |
} |
| 1875 | 1875 |
|
| ... | ... | |
| 1963 | 1963 |
TCPCharDriver *s = chr->opaque; |
| 1964 | 1964 |
if (!s->connected) |
| 1965 | 1965 |
return 0; |
| 1966 |
s->max_size = qemu_chr_can_read(chr);
|
|
| 1966 |
s->max_size = qemu_chr_be_can_write(chr);
|
|
| 1967 | 1967 |
return s->max_size; |
| 1968 | 1968 |
} |
| 1969 | 1969 |
|
| b/qemu-char.h | ||
|---|---|---|
| 96 | 96 |
void *opaque); |
| 97 | 97 |
int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg); |
| 98 | 98 |
void qemu_chr_generic_open(CharDriverState *s); |
| 99 |
int qemu_chr_can_read(CharDriverState *s);
|
|
| 99 |
int qemu_chr_be_can_write(CharDriverState *s);
|
|
| 100 | 100 |
void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len); |
| 101 | 101 |
int qemu_chr_get_msgfd(CharDriverState *s); |
| 102 | 102 |
void qemu_chr_accept_input(CharDriverState *s); |
| b/spice-qemu-char.c | ||
|---|---|---|
| 36 | 36 |
|
| 37 | 37 |
while (len > 0) {
|
| 38 | 38 |
last_out = MIN(len, VMC_MAX_HOST_WRITE); |
| 39 |
if (qemu_chr_can_read(scd->chr) < last_out) {
|
|
| 39 |
if (qemu_chr_be_can_write(scd->chr) < last_out) {
|
|
| 40 | 40 |
break; |
| 41 | 41 |
} |
| 42 | 42 |
qemu_chr_be_write(scd->chr, p, last_out); |
Also available in: Unified diff