Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging
[qemu.git] / tools / virtiofsd / buffer.c
1 /*
2 * FUSE: Filesystem in Userspace
3 * Copyright (C) 2010 Miklos Szeredi <miklos@szeredi.hu>
4 *
5 * Functions for dealing with `struct fuse_buf` and `struct
6 * fuse_bufvec`.
7 *
8 * This program can be distributed under the terms of the GNU LGPLv2.
9 * See the file COPYING.LIB
10 */
11
12 #include "qemu/osdep.h"
13 #include "fuse_i.h"
14 #include "fuse_lowlevel.h"
15
16 size_t fuse_buf_size(const struct fuse_bufvec *bufv)
17 {
18 size_t i;
19 size_t size = 0;
20
21 for (i = 0; i < bufv->count; i++) {
22 if (bufv->buf[i].size == SIZE_MAX) {
23 size = SIZE_MAX;
24 } else {
25 size += bufv->buf[i].size;
26 }
27 }
28
29 return size;
30 }
31
32 static ssize_t fuse_buf_writev(struct fuse_buf *out_buf,
33 struct fuse_bufvec *in_buf)
34 {
35 ssize_t res, i, j;
36 size_t iovcnt = in_buf->count;
37 struct iovec *iov;
38 int fd = out_buf->fd;
39
40 iov = g_try_new0(struct iovec, iovcnt);
41 if (!iov) {
42 return -ENOMEM;
43 }
44
45 for (i = 0, j = 0; i < iovcnt; i++) {
46 /* Skip the buf with 0 size */
47 if (in_buf->buf[i].size) {
48 iov[j].iov_base = in_buf->buf[i].mem;
49 iov[j].iov_len = in_buf->buf[i].size;
50 j++;
51 }
52 }
53
54 if (out_buf->flags & FUSE_BUF_FD_SEEK) {
55 res = pwritev(fd, iov, iovcnt, out_buf->pos);
56 } else {
57 res = writev(fd, iov, iovcnt);
58 }
59
60 if (res == -1) {
61 res = -errno;
62 }
63
64 g_free(iov);
65 return res;
66 }
67
68 static size_t min_size(size_t s1, size_t s2)
69 {
70 return s1 < s2 ? s1 : s2;
71 }
72
73 static ssize_t fuse_buf_write(const struct fuse_buf *dst, size_t dst_off,
74 const struct fuse_buf *src, size_t src_off,
75 size_t len)
76 {
77 ssize_t res = 0;
78 size_t copied = 0;
79
80 while (len) {
81 if (dst->flags & FUSE_BUF_FD_SEEK) {
82 res = pwrite(dst->fd, (char *)src->mem + src_off, len,
83 dst->pos + dst_off);
84 } else {
85 res = write(dst->fd, (char *)src->mem + src_off, len);
86 }
87 if (res == -1) {
88 if (!copied) {
89 return -errno;
90 }
91 break;
92 }
93 if (res == 0) {
94 break;
95 }
96
97 copied += res;
98 if (!(dst->flags & FUSE_BUF_FD_RETRY)) {
99 break;
100 }
101
102 src_off += res;
103 dst_off += res;
104 len -= res;
105 }
106
107 return copied;
108 }
109
110 static ssize_t fuse_buf_read(const struct fuse_buf *dst, size_t dst_off,
111 const struct fuse_buf *src, size_t src_off,
112 size_t len)
113 {
114 ssize_t res = 0;
115 size_t copied = 0;
116
117 while (len) {
118 if (src->flags & FUSE_BUF_FD_SEEK) {
119 res = pread(src->fd, (char *)dst->mem + dst_off, len,
120 src->pos + src_off);
121 } else {
122 res = read(src->fd, (char *)dst->mem + dst_off, len);
123 }
124 if (res == -1) {
125 if (!copied) {
126 return -errno;
127 }
128 break;
129 }
130 if (res == 0) {
131 break;
132 }
133
134 copied += res;
135 if (!(src->flags & FUSE_BUF_FD_RETRY)) {
136 break;
137 }
138
139 dst_off += res;
140 src_off += res;
141 len -= res;
142 }
143
144 return copied;
145 }
146
147 static ssize_t fuse_buf_fd_to_fd(const struct fuse_buf *dst, size_t dst_off,
148 const struct fuse_buf *src, size_t src_off,
149 size_t len)
150 {
151 char buf[4096];
152 struct fuse_buf tmp = {
153 .size = sizeof(buf),
154 .flags = 0,
155 };
156 ssize_t res;
157 size_t copied = 0;
158
159 tmp.mem = buf;
160
161 while (len) {
162 size_t this_len = min_size(tmp.size, len);
163 size_t read_len;
164
165 res = fuse_buf_read(&tmp, 0, src, src_off, this_len);
166 if (res < 0) {
167 if (!copied) {
168 return res;
169 }
170 break;
171 }
172 if (res == 0) {
173 break;
174 }
175
176 read_len = res;
177 res = fuse_buf_write(dst, dst_off, &tmp, 0, read_len);
178 if (res < 0) {
179 if (!copied) {
180 return res;
181 }
182 break;
183 }
184 if (res == 0) {
185 break;
186 }
187
188 copied += res;
189
190 if (res < this_len) {
191 break;
192 }
193
194 dst_off += res;
195 src_off += res;
196 len -= res;
197 }
198
199 return copied;
200 }
201
202 static ssize_t fuse_buf_copy_one(const struct fuse_buf *dst, size_t dst_off,
203 const struct fuse_buf *src, size_t src_off,
204 size_t len)
205 {
206 int src_is_fd = src->flags & FUSE_BUF_IS_FD;
207 int dst_is_fd = dst->flags & FUSE_BUF_IS_FD;
208
209 if (!src_is_fd && !dst_is_fd) {
210 char *dstmem = (char *)dst->mem + dst_off;
211 char *srcmem = (char *)src->mem + src_off;
212
213 if (dstmem != srcmem) {
214 if (dstmem + len <= srcmem || srcmem + len <= dstmem) {
215 memcpy(dstmem, srcmem, len);
216 } else {
217 memmove(dstmem, srcmem, len);
218 }
219 }
220
221 return len;
222 } else if (!src_is_fd) {
223 return fuse_buf_write(dst, dst_off, src, src_off, len);
224 } else if (!dst_is_fd) {
225 return fuse_buf_read(dst, dst_off, src, src_off, len);
226 } else {
227 return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
228 }
229 }
230
231 static const struct fuse_buf *fuse_bufvec_current(struct fuse_bufvec *bufv)
232 {
233 if (bufv->idx < bufv->count) {
234 return &bufv->buf[bufv->idx];
235 } else {
236 return NULL;
237 }
238 }
239
240 static int fuse_bufvec_advance(struct fuse_bufvec *bufv, size_t len)
241 {
242 const struct fuse_buf *buf = fuse_bufvec_current(bufv);
243
244 if (!buf) {
245 return 0;
246 }
247
248 bufv->off += len;
249 assert(bufv->off <= buf->size);
250 if (bufv->off == buf->size) {
251 assert(bufv->idx < bufv->count);
252 bufv->idx++;
253 if (bufv->idx == bufv->count) {
254 return 0;
255 }
256 bufv->off = 0;
257 }
258 return 1;
259 }
260
261 ssize_t fuse_buf_copy(struct fuse_bufvec *dstv, struct fuse_bufvec *srcv)
262 {
263 size_t copied = 0, i;
264
265 if (dstv == srcv) {
266 return fuse_buf_size(dstv);
267 }
268
269 /*
270 * use writev to improve bandwidth when all the
271 * src buffers already mapped by the daemon
272 * process
273 */
274 for (i = 0; i < srcv->count; i++) {
275 if (srcv->buf[i].flags & FUSE_BUF_IS_FD) {
276 break;
277 }
278 }
279 if ((i == srcv->count) && (dstv->count == 1) &&
280 (dstv->idx == 0) &&
281 (dstv->buf[0].flags & FUSE_BUF_IS_FD)) {
282 dstv->buf[0].pos += dstv->off;
283 return fuse_buf_writev(&dstv->buf[0], srcv);
284 }
285
286 for (;;) {
287 const struct fuse_buf *src = fuse_bufvec_current(srcv);
288 const struct fuse_buf *dst = fuse_bufvec_current(dstv);
289 size_t src_len;
290 size_t dst_len;
291 size_t len;
292 ssize_t res;
293
294 if (src == NULL || dst == NULL) {
295 break;
296 }
297
298 src_len = src->size - srcv->off;
299 dst_len = dst->size - dstv->off;
300 len = min_size(src_len, dst_len);
301
302 res = fuse_buf_copy_one(dst, dstv->off, src, srcv->off, len);
303 if (res < 0) {
304 if (!copied) {
305 return res;
306 }
307 break;
308 }
309 copied += res;
310
311 if (!fuse_bufvec_advance(srcv, res) ||
312 !fuse_bufvec_advance(dstv, res)) {
313 break;
314 }
315
316 if (res < len) {
317 break;
318 }
319 }
320
321 return copied;
322 }
323
324 void *fuse_mbuf_iter_advance(struct fuse_mbuf_iter *iter, size_t len)
325 {
326 void *ptr;
327
328 if (len > iter->size - iter->pos) {
329 return NULL;
330 }
331
332 ptr = iter->mem + iter->pos;
333 iter->pos += len;
334 return ptr;
335 }
336
337 const char *fuse_mbuf_iter_advance_str(struct fuse_mbuf_iter *iter)
338 {
339 const char *str = iter->mem + iter->pos;
340 size_t remaining = iter->size - iter->pos;
341 size_t i;
342
343 for (i = 0; i < remaining; i++) {
344 if (str[i] == '\0') {
345 iter->pos += i + 1;
346 return str;
347 }
348 }
349 return NULL;
350 }