1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
#include <stdint.h>
#include <stdbool.h>
#include <uv.h>
#include "nvim/os/uv_helpers.h"
#include "nvim/os/wstream.h"
#include "nvim/os/wstream_defs.h"
#include "nvim/vim.h"
#include "nvim/memory.h"
struct wstream {
uv_stream_t *stream;
// Memory currently used by pending buffers
size_t curmem;
// Maximum memory used by this instance
size_t maxmem;
// Number of pending requests
size_t pending_reqs;
bool freed;
};
struct wbuffer {
size_t refcount, size;
char *data;
};
typedef struct {
WStream *wstream;
WBuffer *buffer;
} WriteData;
static void write_cb(uv_write_t *req, int status);
WStream * wstream_new(size_t maxmem)
{
WStream *rv = xmalloc(sizeof(WStream));
rv->maxmem = maxmem;
rv->stream = NULL;
rv->curmem = 0;
rv->pending_reqs = 0;
rv->freed = false;
return rv;
}
void wstream_free(WStream *wstream)
{
if (!wstream->pending_reqs) {
free(wstream);
} else {
wstream->freed = true;
}
}
void wstream_set_stream(WStream *wstream, uv_stream_t *stream)
{
handle_set_wstream((uv_handle_t *)stream, wstream);
wstream->stream = stream;
}
bool wstream_write(WStream *wstream, WBuffer *buffer)
{
WriteData *data;
uv_buf_t uvbuf;
uv_write_t *req;
// This should not be called after a wstream was freed
assert(!wstream->freed);
if (wstream->curmem + buffer->size > wstream->maxmem) {
return false;
}
buffer->refcount++;
wstream->curmem += buffer->size;
data = xmalloc(sizeof(WriteData));
data->wstream = wstream;
data->buffer = buffer;
req = xmalloc(sizeof(uv_write_t));
req->data = data;
uvbuf.base = buffer->data;
uvbuf.len = buffer->size;
wstream->pending_reqs++;
uv_write(req, wstream->stream, &uvbuf, 1, write_cb);
return true;
}
WBuffer *wstream_new_buffer(char *data, size_t size, bool copy)
{
WBuffer *rv = xmalloc(sizeof(WBuffer));
rv->size = size;
rv->refcount = 0;
if (copy) {
rv->data = xmemdup(data, size);
} else {
rv->data = data;
}
return rv;
}
static void write_cb(uv_write_t *req, int status)
{
WriteData *data = req->data;
free(req);
data->wstream->curmem -= data->buffer->size;
if (!--data->buffer->refcount) {
// Free the data written to the stream
free(data->buffer->data);
free(data->buffer);
}
data->wstream->pending_reqs--;
if (data->wstream->freed && data->wstream->pending_reqs == 0) {
// Last pending write, free the wstream;
free(data->wstream);
}
free(data);
}
|
