Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/fsdev/9p-iov-marshal.c
Line
Count
Source
1
/*
2
 * 9p backend
3
 *
4
 * Copyright IBM, Corp. 2010
5
 *
6
 * Authors:
7
 *  Anthony Liguori   <aliguori@us.ibm.com>
8
 *
9
 * This work is licensed under the terms of the GNU GPL, version 2.  See
10
 * the COPYING file in the top-level directory.
11
 *
12
 */
13
14
#include "qemu/osdep.h"
15
#include <glib/gprintf.h>
16
#include <utime.h>
17
18
#include "9p-iov-marshal.h"
19
#include "qemu/bswap.h"
20
21
static ssize_t v9fs_packunpack(void *addr, struct iovec *sg, int sg_count,
22
                               size_t offset, size_t size, int pack)
23
1.88M
{
24
1.88M
    int i = 0;
25
1.88M
    size_t copied = 0;
26
1.88M
    size_t req_size = size;
27
28
29
3.73M
    for (i = 0; size && i < sg_count; i++) {
30
1.85M
        size_t len;
31
1.85M
        if (offset >= sg[i].iov_len) {
32
            /* skip this sg */
33
6.48k
            offset -= sg[i].iov_len;
34
6.48k
            continue;
35
1.84M
        } else {
36
1.84M
            len = MIN(sg[i].iov_len - offset, size);
37
1.84M
            if (pack) {
38
963k
                memcpy(sg[i].iov_base + offset, addr, len);
39
963k
            } else {
40
880k
                memcpy(addr, sg[i].iov_base + offset, len);
41
880k
            }
42
1.84M
            size -= len;
43
1.84M
            copied += len;
44
1.84M
            addr += len;
45
1.84M
            if (size) {
46
6.80k
                offset = 0;
47
6.80k
                continue;
48
6.80k
            }
49
1.84M
        }
50
1.85M
    }
51
1.88M
    if (copied < req_size) {
52
        /*
53
         * We copied less that requested size. error out
54
         */
55
6.58k
        return -ENOBUFS;
56
6.58k
    }
57
1.87M
    return copied;
58
1.88M
}
59
60
static ssize_t v9fs_unpack(void *dst, struct iovec *out_sg, int out_num,
61
                           size_t offset, size_t size)
62
920k
{
63
920k
    return v9fs_packunpack(dst, out_sg, out_num, offset, size, 0);
64
920k
}
65
66
ssize_t v9fs_pack(struct iovec *in_sg, int in_num, size_t offset,
67
                  const void *src, size_t size)
68
962k
{
69
962k
    return v9fs_packunpack((void *)src, in_sg, in_num, offset, size, 1);
70
962k
}
71
72
ssize_t v9fs_iov_vunmarshal(struct iovec *out_sg, int out_num, size_t offset,
73
                            int bswap, const char *fmt, va_list ap)
74
351k
{
75
351k
    int i;
76
351k
    ssize_t copied = 0;
77
351k
    size_t old_offset = offset;
78
79
1.29M
    for (i = 0; fmt[i]; i++) {
80
945k
        switch (fmt[i]) {
81
3.99k
        case 'b': {
82
3.99k
            uint8_t *valp = va_arg(ap, uint8_t *);
83
3.99k
            copied = v9fs_unpack(valp, out_sg, out_num, offset, sizeof(*valp));
84
3.99k
            break;
85
0
        }
86
211k
        case 'w': {
87
211k
            uint16_t val = 0, *valp;
88
211k
            valp = va_arg(ap, uint16_t *);
89
211k
            copied = v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val));
90
211k
            if (copied <= 0) {
91
658
                break;
92
658
            }
93
210k
            if (bswap) {
94
210k
                *valp = le16_to_cpu(val);
95
210k
            } else {
96
0
                *valp = val;
97
0
            }
98
210k
            break;
99
211k
        }
100
402k
        case 'd': {
101
402k
            uint32_t val = 0, *valp;
102
402k
            valp = va_arg(ap, uint32_t *);
103
402k
            copied = v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val));
104
402k
            if (copied <= 0) {
105
1.02k
                break;
106
1.02k
            }
107
401k
            if (bswap) {
108
401k
                *valp = le32_to_cpu(val);
109
401k
            } else {
110
0
                *valp = val;
111
0
            }
112
401k
            break;
113
402k
        }
114
102k
        case 'q': {
115
102k
            uint64_t val = 0, *valp;
116
102k
            valp = va_arg(ap, uint64_t *);
117
102k
            copied = v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val));
118
102k
            if (copied <= 0) {
119
72
                break;
120
72
            }
121
102k
            if (bswap) {
122
102k
                *valp = le64_to_cpu(val);
123
102k
            } else {
124
0
                *valp = val;
125
0
            }
126
102k
            break;
127
102k
        }
128
199k
        case 's': {
129
199k
            V9fsString *str = va_arg(ap, V9fsString *);
130
199k
            copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap,
131
199k
                                        "w", &str->size);
132
199k
            if (copied > 0) {
133
199k
                offset += copied;
134
199k
                str->data = g_malloc(str->size + 1);
135
199k
                copied = v9fs_unpack(str->data, out_sg, out_num, offset,
136
199k
                                     str->size);
137
199k
                if (copied >= 0) {
138
196k
                    str->data[str->size] = 0;
139
196k
                } else {
140
2.29k
                    v9fs_string_free(str);
141
2.29k
                }
142
199k
            }
143
199k
            break;
144
102k
        }
145
3.10k
        case 'Q': {
146
3.10k
            V9fsQID *qidp = va_arg(ap, V9fsQID *);
147
3.10k
            copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap,
148
3.10k
                                        "bdq", &qidp->type, &qidp->version,
149
3.10k
                                        &qidp->path);
150
3.10k
            break;
151
102k
        }
152
3.10k
        case 'S': {
153
3.10k
            V9fsStat *statp = va_arg(ap, V9fsStat *);
154
3.10k
            copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap,
155
3.10k
                                        "wwdQdddqsssssddd",
156
3.10k
                                        &statp->size, &statp->type,
157
3.10k
                                        &statp->dev, &statp->qid,
158
3.10k
                                        &statp->mode, &statp->atime,
159
3.10k
                                        &statp->mtime, &statp->length,
160
3.10k
                                        &statp->name, &statp->uid,
161
3.10k
                                        &statp->gid, &statp->muid,
162
3.10k
                                        &statp->extension,
163
3.10k
                                        &statp->n_uid, &statp->n_gid,
164
3.10k
                                        &statp->n_muid);
165
3.10k
            break;
166
102k
        }
167
18.5k
        case 'I': {
168
18.5k
            V9fsIattr *iattr = va_arg(ap, V9fsIattr *);
169
18.5k
            copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap,
170
18.5k
                                        "ddddqqqqq",
171
18.5k
                                        &iattr->valid, &iattr->mode,
172
18.5k
                                        &iattr->uid, &iattr->gid,
173
18.5k
                                        &iattr->size, &iattr->atime_sec,
174
18.5k
                                        &iattr->atime_nsec,
175
18.5k
                                        &iattr->mtime_sec,
176
18.5k
                                        &iattr->mtime_nsec);
177
18.5k
            break;
178
102k
        }
179
0
        default:
180
0
            g_assert_not_reached();
181
945k
        }
182
945k
        if (copied < 0) {
183
5.24k
            return copied;
184
5.24k
        }
185
940k
        offset += copied;
186
940k
    }
187
188
346k
    return offset - old_offset;
189
351k
}
190
191
ssize_t v9fs_iov_unmarshal(struct iovec *out_sg, int out_num, size_t offset,
192
                           int bswap, const char *fmt, ...)
193
224k
{
194
224k
    ssize_t ret;
195
224k
    va_list ap;
196
197
224k
    va_start(ap, fmt);
198
224k
    ret = v9fs_iov_vunmarshal(out_sg, out_num, offset, bswap, fmt, ap);
199
224k
    va_end(ap);
200
201
224k
    return ret;
202
224k
}
203
204
ssize_t v9fs_iov_vmarshal(struct iovec *in_sg, int in_num, size_t offset,
205
                          int bswap, const char *fmt, va_list ap)
206
539k
{
207
539k
    int i;
208
539k
    ssize_t copied = 0;
209
539k
    size_t old_offset = offset;
210
211
1.53M
    for (i = 0; fmt[i]; i++) {
212
995k
        switch (fmt[i]) {
213
227k
        case 'b': {
214
227k
            uint8_t val = va_arg(ap, int);
215
227k
            copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));
216
227k
            break;
217
0
        }
218
253k
        case 'w': {
219
253k
            uint16_t val = va_arg(ap, int);
220
253k
            if (bswap) {
221
253k
                val = cpu_to_le16(val);
222
253k
            }
223
253k
            copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));
224
253k
            break;
225
0
        }
226
390k
        case 'd': {
227
390k
            uint32_t val = va_arg(ap, uint32_t);
228
390k
            if (bswap) {
229
390k
                val = cpu_to_le32(val);
230
390k
            }
231
390k
            copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));
232
390k
            break;
233
0
        }
234
32.7k
        case 'q': {
235
32.7k
            uint64_t val = va_arg(ap, uint64_t);
236
32.7k
            if (bswap) {
237
32.7k
                val = cpu_to_le64(val);
238
32.7k
            }
239
32.7k
            copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));
240
32.7k
            break;
241
0
        }
242
58.8k
        case 's': {
243
58.8k
            V9fsString *str = va_arg(ap, V9fsString *);
244
58.8k
            copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap,
245
58.8k
                                      "w", str->size);
246
58.8k
            if (copied > 0) {
247
58.8k
                offset += copied;
248
58.8k
                copied = v9fs_pack(in_sg, in_num, offset, str->data, str->size);
249
58.8k
            }
250
58.8k
            break;
251
0
        }
252
32.7k
        case 'Q': {
253
32.7k
            V9fsQID *qidp = va_arg(ap, V9fsQID *);
254
32.7k
            copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap, "bdq",
255
32.7k
                                      qidp->type, qidp->version,
256
32.7k
                                      qidp->path);
257
32.7k
            break;
258
0
        }
259
0
        case 'S': {
260
0
            V9fsStat *statp = va_arg(ap, V9fsStat *);
261
0
            copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap,
262
0
                                      "wwdQdddqsssssddd",
263
0
                                      statp->size, statp->type, statp->dev,
264
0
                                      &statp->qid, statp->mode, statp->atime,
265
0
                                      statp->mtime, statp->length,
266
0
                                      &statp->name,
267
0
                                      &statp->uid, &statp->gid, &statp->muid,
268
0
                                      &statp->extension, statp->n_uid,
269
0
                                      statp->n_gid, statp->n_muid);
270
0
            break;
271
0
        }
272
0
        case 'A': {
273
0
            V9fsStatDotl *statp = va_arg(ap, V9fsStatDotl *);
274
0
            copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap,
275
0
                                      "qQdddqqqqqqqqqqqqqqq",
276
0
                                      statp->st_result_mask,
277
0
                                      &statp->qid, statp->st_mode,
278
0
                                      statp->st_uid, statp->st_gid,
279
0
                                      statp->st_nlink, statp->st_rdev,
280
0
                                      statp->st_size, statp->st_blksize,
281
0
                                      statp->st_blocks, statp->st_atime_sec,
282
0
                                      statp->st_atime_nsec,
283
0
                                      statp->st_mtime_sec,
284
0
                                      statp->st_mtime_nsec,
285
0
                                      statp->st_ctime_sec,
286
0
                                      statp->st_ctime_nsec,
287
0
                                      statp->st_btime_sec,
288
0
                                      statp->st_btime_nsec, statp->st_gen,
289
0
                                      statp->st_data_version);
290
0
            break;
291
0
        }
292
0
        default:
293
0
            g_assert_not_reached();
294
995k
        }
295
995k
        if (copied < 0) {
296
2.58k
            return copied;
297
2.58k
        }
298
992k
        offset += copied;
299
992k
    }
300
301
536k
    return offset - old_offset;
302
539k
}
303
304
ssize_t v9fs_iov_marshal(struct iovec *in_sg, int in_num, size_t offset,
305
                         int bswap, const char *fmt, ...)
306
91.6k
{
307
91.6k
    ssize_t ret;
308
91.6k
    va_list ap;
309
310
91.6k
    va_start(ap, fmt);
311
91.6k
    ret = v9fs_iov_vmarshal(in_sg, in_num, offset, bswap, fmt, ap);
312
91.6k
    va_end(ap);
313
314
91.6k
    return ret;
315
91.6k
}