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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
#include <sys/cdefs.h>
#include <lib.h>
#include "namespace.h"
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/uio.h>
#include <unistd.h>
/*
* Create a single temporary buffer for the entire vector. For writes, also
* copy the actual data into the temporary buffer.
*/
ssize_t
_vectorio_setup(const struct iovec * iov, int iovcnt, char ** ptr, int op)
{
char *buffer;
ssize_t totallen, copied;
int i;
/* Parameter sanity checks. */
if (iovcnt < 0 || iovcnt > IOV_MAX) {
errno = EINVAL;
return -1;
}
totallen = 0;
for (i = 0; i < iovcnt; i++) {
/* Do not read/write anything in case of possible overflow. */
if ((size_t)SSIZE_MAX - totallen < iov[i].iov_len) {
errno = EINVAL;
return -1;
}
totallen += iov[i].iov_len;
/* Report on NULL pointers. */
if (iov[i].iov_len > 0 && iov[i].iov_base == NULL) {
errno = EFAULT;
return -1;
}
}
/* Anything to do? */
if (totallen == 0) {
*ptr = NULL;
return 0;
}
/* Allocate a temporary buffer. */
buffer = (char *)malloc(totallen);
if (buffer == NULL)
return -1;
/* For writes, copy over the buffer contents before the call. */
if (op == _VECTORIO_WRITE) {
copied = 0;
for (i = 0; i < iovcnt; i++) {
memcpy(buffer + copied, iov[i].iov_base,
iov[i].iov_len);
copied += iov[i].iov_len;
}
assert(copied == totallen);
}
/* Return the temporary buffer and its size. */
*ptr = buffer;
return totallen;
}
/*
* Clean up the temporary buffer created for the vector. For successful reads,
* also copy out the retrieved buffer contents.
*/
void
_vectorio_cleanup(const struct iovec * iov, int iovcnt, char * buffer,
ssize_t r, int op)
{
int i, errno_saved;
ssize_t copied, len;
/* Make sure to retain the original errno value in case of failure. */
errno_saved = errno;
/*
* If this was for a read and the read call succeeded, copy out the
* resulting data.
*/
if (op == _VECTORIO_READ && r > 0) {
assert(buffer != NULL);
copied = 0;
i = 0;
while (copied < r) {
assert(i < iovcnt);
len = iov[i].iov_len;
if (len > r - copied)
len = r - copied;
memcpy(iov[i++].iov_base, buffer + copied, len);
copied += len;
}
assert(r < 0 || r == copied);
}
/* Free the temporary buffer. */
if (buffer != NULL)
free(buffer);
errno = errno_saved;
}
/*
* Read a vector.
*/
ssize_t
readv(int fd, const struct iovec * iov, int iovcnt)
{
char *ptr;
ssize_t r;
/*
* There ought to be just a readv system call here. Instead, we use an
* intermediate buffer. This approach is preferred over multiple read
* calls, because the actual I/O operation has to be atomic.
*/
if ((r = _vectorio_setup(iov, iovcnt, &ptr, _VECTORIO_READ)) <= 0)
return r;
r = read(fd, ptr, r);
_vectorio_cleanup(iov, iovcnt, ptr, r, _VECTORIO_READ);
return r;
}
/*
* Write a vector.
*/
ssize_t
writev(int fd, const struct iovec * iov, int iovcnt)
{
char *ptr;
ssize_t r;
/*
* There ought to be just a writev system call here. Instead, we use
* an intermediate buffer. This approach is preferred over multiple
* write calls, because the actual I/O operation has to be atomic.
*/
if ((r = _vectorio_setup(iov, iovcnt, &ptr, _VECTORIO_WRITE)) <= 0)
return r;
r = write(fd, ptr, r);
_vectorio_cleanup(iov, iovcnt, ptr, r, _VECTORIO_WRITE);
return r;
}
|
