12180976347

Committed 05 Dec 2024 01:42PM UTC coverage: 87.325% (-0.03%) from 87.359%

Build # 12180976347

Build Type

push

github

Committed by

Totktonada

Commit Message

config: fix schema:get()/set() changes passed path

This patch makes `schema:get()`, `schema:set()` and `config:get()` not
change the passed path argument when it is a table.

The problem was in the way the walkthrough process is set up during the
`schema:get()` and `schema:set()` method execution. These methods used
`walkthrough_start()` performing a shallow copy of the passed option
table containing the information on the desired path. The value of
the path was modified during the walkthrough itself. The patch makes
the methods perform a shallow copy of the path field. It also fixes
`config:get()` since it's internally uses `schema:get()`.

This is how broken scenario could be reproduced when using
`config:get()`:
```
tarantool> config = require('config')
tarantool> path = {'fiber', 'slice'}
tarantool> config:get(path)
---
- err: 1
  warn: 0.5
...

tarantool> path
---
- []
...
```

Closes #10855

NO_DOC=bugfix

(cherry picked from commit fb5740cae)

Run Details

69618 of 123486 branches covered (56.38%)

102563 of 117450 relevant lines covered (87.32%)

2944960.45 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

60.84

/src/lib/core/fio.c

/*
 * Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 * 1. Redistributions of source code must retain the above
 *    copyright notice, this list of conditions and the
 *    following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include "fio.h"

#include <sys/types.h>

#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <errno.h>
#include <lib/bit/bit.h>

#include <say.h>
#include "tt_static.h"

const char *
fio_filename(int fd)
{
#if TARGET_OS_LINUX
        int save_errno = errno;

        char *proc_path = tt_static_buf();
        snprintf(proc_path, TT_STATIC_BUF_LEN, "/proc/self/fd/%d", fd);
        char *filename_path = tt_static_buf();

        ssize_t sz = readlink(proc_path, filename_path, TT_STATIC_BUF_LEN);
        errno = save_errno;
        if (sz >= 0) {
                sz = MIN(sz, TT_STATIC_BUF_LEN - 1);
                filename_path[sz] = '\0';
                return filename_path;
        }
#else /* TARGET_OS_LINUX */
        (void) fd;
#endif
        return ""; /* Not implemented. */
}

ssize_t
fio_read(int fd, void *buf, size_t count)
{
        size_t n = 0;
        do {
                ssize_t nrd = read(fd, buf + n, count - n);
                if (nrd < 0) {
                        if (errno == EINTR) {
                                errno = 0;
                                continue;
                        }
                        say_syserror("read, [%s]", fio_filename(fd));
                        return -1; /* XXX: file position is unspecified */
                } else if (nrd == 0) {
                        break; /* EOF */
                }
                n += nrd;
        } while (n < count);

        assert(n <= count);
        return n;
}

ssize_t
fio_pread(int fd, void *buf, size_t count, off_t offset)
{
        size_t n = 0;
        do {
                ssize_t nrd = pread(fd, buf + n, count - n, offset + n);
                if (nrd < 0) {
                        if (errno == EINTR) {
                                errno = 0;
                                continue;
                        }
                        say_syserror("pread, [%s]", fio_filename(fd));
                        return -1;
                } else if (nrd == 0) {
                        break; /* EOF */
                }
                n += nrd;
        } while (n < count);

        assert(n <= count);
        return n;
}

int
fio_writen(int fd, const void *buf, size_t count)
{
        ssize_t to_write = (ssize_t) count;
        while (to_write > 0) {
                ssize_t nwr = write(fd, buf, to_write);
                if (nwr < 0) {
                        if (errno == EINTR) {
                                errno = 0;
                                continue;
                        }
                        say_syserror("write, [%s]", fio_filename(fd));
                        return -1; /* XXX: file position is unspecified */
                }
                buf += nwr;
                to_write -= nwr;
        }
        assert(to_write == 0);

        return 0;
}

ssize_t
fio_writev(int fd, struct iovec *iov, int iovcnt)
{
        assert(iov && iovcnt >= 0);
        ssize_t nwr;
restart:
        nwr = writev(fd, iov, iovcnt);
        if (nwr < 0) {
                if (errno == EINTR) {
                        errno = 0;
                        goto restart;
                }
                if (errno != EAGAIN && errno != EWOULDBLOCK)
                        say_syserror("writev, [%s]", fio_filename(fd));
        }
        return nwr;
}

ssize_t
fio_writevn(int fd, struct iovec *iov, int iovcnt)
{
        assert(iov && iovcnt >= 0);
        ssize_t nwr = 0;
        int iov_pos = 0;
        struct fio_batch *batch = fio_batch_new();
        while (iov_pos < iovcnt) {
                int iov_to_batch = MIN(batch->max_iov, iovcnt - iov_pos);
                memmove(batch->iov + batch->iovcnt, iov + iov_pos,
                        sizeof(struct iovec) * iov_to_batch);
                fio_batch_add(batch, iov_to_batch);
                iov_pos += iov_to_batch;
                while (batch->iovcnt) {
                        ssize_t written = fio_batch_write(batch, fd);
                        if (written < 0) {
                                fio_batch_delete(batch);
                                return -1;
                        }
                        nwr += written;
                }
        }
        fio_batch_delete(batch);
        return nwr;
}

off_t
fio_lseek(int fd, off_t offset, int whence)
{
        off_t effective_offset = lseek(fd, offset, whence);

        if (effective_offset == -1) {
                say_syserror("lseek, [%s]: offset=%jd, whence=%d",
                             fio_filename(fd), (intmax_t) offset, whence);
        } else if (whence == SEEK_SET && effective_offset != offset) {
                say_error("lseek, [%s]: offset set to unexpected value: "
                          "requested %jd effective %jd",
                          fio_filename(fd),
                          (intmax_t)offset, (intmax_t)effective_offset);
        }
        return effective_offset;
}

int
fio_truncate(int fd, off_t offset)
{
        int rc = ftruncate(fd, offset);
        if (rc)
                say_syserror("fio_truncate, [%s]: offset=%jd",
                             fio_filename(fd), (intmax_t) offset);
        return rc;
}


struct fio_batch *
fio_batch_new(void)
{
        int max_iov = sysconf(_SC_IOV_MAX);
        if (max_iov < 1)
                max_iov = IOV_MAX;

        struct fio_batch *batch = (struct fio_batch *)
                malloc(sizeof(struct fio_batch) +
                       sizeof(struct iovec) * max_iov);
        if (batch == NULL)
                return NULL;

        fio_batch_reset(batch);
        batch->max_iov = max_iov;
        return batch;
}

void
fio_batch_delete(struct fio_batch *batch)
{
        free(batch);
}

size_t
fio_batch_add(struct fio_batch *batch, int count)
{
        assert(batch->iovcnt + count <= batch->max_iov);

        size_t total_bytes = 0;
        struct iovec *iov = batch->iov + batch->iovcnt;
        struct iovec *end = iov + count;
        for (; iov != end; ++iov) {
                assert(iov->iov_base != NULL && iov->iov_len > 0);
                total_bytes += iov->iov_len;
        }
        batch->iovcnt += count;
        batch->bytes += total_bytes;
        return total_bytes;
}

/**
 * Rotate batch after partial write.
 */
static inline void
fio_batch_rotate(struct fio_batch *batch, size_t bytes_written)
{
        /*
         * writev(2) usually fully write all data on local filesystems.
         */
        if (likely(bytes_written == batch->bytes)) {
                /* Full write */
                fio_batch_reset(batch);
                return;
        }

        assert(bytes_written < batch->bytes); /* Partial write */
        batch->bytes -= bytes_written;

        struct iovec *iov = batch->iov;
        struct iovec *iovend = iov + batch->iovcnt;
        for (; iov < iovend; ++iov) {
                if (iov->iov_len > bytes_written) {
                        iov->iov_base = (char *) iov->iov_base + bytes_written;
                        iov->iov_len -= bytes_written;
                        break;
                }
                bytes_written -= iov->iov_len;
        }
        assert(iov < iovend); /* Partial write  */
        memmove(batch->iov, iov, (iovend - iov) * sizeof(struct iovec));
        batch->iovcnt = iovend - iov;
}

ssize_t
fio_batch_write(struct fio_batch *batch, int fd)
{
        ssize_t bytes_written = fio_writev(fd, batch->iov, batch->iovcnt);
        if (unlikely(bytes_written <= 0))
                return -1; /* Error */

        fio_batch_rotate(batch, bytes_written);
        return bytes_written;
}

1	/*
2	* Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
3	*
4	* Redistribution and use in source and binary forms, with or
5	* without modification, are permitted provided that the following
6	* conditions are met:
7	*
8	* 1. Redistributions of source code must retain the above
9	* copyright notice, this list of conditions and the
10	* following disclaimer.
11	*
12	* 2. Redistributions in binary form must reproduce the above
13	* copyright notice, this list of conditions and the following
14	* disclaimer in the documentation and/or other materials
15	* provided with the distribution.
16	*
17	* THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21	* <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
22	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
28	* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29	* SUCH DAMAGE.
30	*/
31	#include "fio.h"
32
33	#include <sys/types.h>
34
35	#include <string.h>
36	#include <unistd.h>
37	#include <errno.h>
38	#include <limits.h>
39	#include <stdio.h>
40	#include <errno.h>
41	#include <lib/bit/bit.h>
42
43	#include <say.h>
44	#include "tt_static.h"
45
46	const char *
47	fio_filename(int fd)	×
48	{
49	#if TARGET_OS_LINUX
50	int save_errno = errno;	×
51
52	char *proc_path = tt_static_buf();	×
53	snprintf(proc_path, TT_STATIC_BUF_LEN, "/proc/self/fd/%d", fd);	×
54	char *filename_path = tt_static_buf();	×
55
56	ssize_t sz = readlink(proc_path, filename_path, TT_STATIC_BUF_LEN);	×
57	errno = save_errno;	×
58	if (sz >= 0) {	×
59	sz = MIN(sz, TT_STATIC_BUF_LEN - 1);	×
60	filename_path[sz] = '\0';	×
61	return filename_path;	×
62	}
63	#else /* TARGET_OS_LINUX */
64	(void) fd;
65	#endif
66	return ""; /* Not implemented. */	×
67	}
68
69	ssize_t
70	fio_read(int fd, void *buf, size_t count)	1,444✔
71	{
72	size_t n = 0;	1,444✔
73	do {
74	ssize_t nrd = read(fd, buf + n, count - n);	2,825✔
75	if (nrd < 0) {	2,825!
76	if (errno == EINTR) {	×
77	errno = 0;	×
78	continue;	×
79	}
80	say_syserror("read, [%s]", fio_filename(fd));	×
81	return -1; /* XXX: file position is unspecified */	×
82	} else if (nrd == 0) {	2,825✔
83	break; /* EOF */	1,382✔
84	}
85	n += nrd;	1,443✔
86	} while (n < count);	1,443✔
87
88	assert(n <= count);	1,444!
89	return n;	1,444✔
90	}
91
92	ssize_t
93	fio_pread(int fd, void *buf, size_t count, off_t offset)	554,151✔
94	{
95	size_t n = 0;	554,151✔
96	do {
97	ssize_t nrd = pread(fd, buf + n, count - n, offset + n);	598,468✔
98	if (nrd < 0) {	598,580!
99	if (errno == EINTR) {	×
100	errno = 0;	×
101	continue;	×
102	}
103	say_syserror("pread, [%s]", fio_filename(fd));	×
104	return -1;	×
105	} else if (nrd == 0) {	598,580✔
106	break; /* EOF */	78,878✔
107	}
108	n += nrd;	519,702✔
109	} while (n < count);	519,702✔
110
111	assert(n <= count);	554,263!
112	return n;	554,263✔
113	}
114
115	int
116	fio_writen(int fd, const void *buf, size_t count)	45,451✔
117	{
118	ssize_t to_write = (ssize_t) count;	45,451✔
119	while (to_write > 0) {	90,901✔
120	ssize_t nwr = write(fd, buf, to_write);	45,451✔
121	if (nwr < 0) {	45,450!
122	if (errno == EINTR) {	×
123	errno = 0;	×
124	continue;	×
125	}
126	say_syserror("write, [%s]", fio_filename(fd));	×
127	return -1; /* XXX: file position is unspecified */	×
128	}
129	buf += nwr;	45,450✔
130	to_write -= nwr;	45,450✔
131	}
132	assert(to_write == 0);	45,450!
133
134	return 0;	45,450✔
135	}
136
137	ssize_t
138	fio_writev(int fd, struct iovec *iov, int iovcnt)	4,189,530✔
139	{
140	assert(iov && iovcnt >= 0);	4,189,530!
141	ssize_t nwr;
142	restart:	4,189,530✔
143	nwr = writev(fd, iov, iovcnt);	4,189,530✔
144	if (nwr < 0) {	4,189,530!
145	if (errno == EINTR) {	×
146	errno = 0;	×
147	goto restart;	×
148	}
149	if (errno != EAGAIN && errno != EWOULDBLOCK)	×
150	say_syserror("writev, [%s]", fio_filename(fd));	×
151	}
152	return nwr;	4,189,540✔
153	}
154
155	ssize_t
156	fio_writevn(int fd, struct iovec *iov, int iovcnt)	4,189,530✔
157	{
158	assert(iov && iovcnt >= 0);	4,189,530!
159	ssize_t nwr = 0;	4,189,530✔
160	int iov_pos = 0;	4,189,530✔
161	struct fio_batch *batch = fio_batch_new();	4,189,530✔
162	while (iov_pos < iovcnt) {	8,379,070✔
163	int iov_to_batch = MIN(batch->max_iov, iovcnt - iov_pos);	4,189,530✔
164	memmove(batch->iov + batch->iovcnt, iov + iov_pos,	4,189,530✔
165	sizeof(struct iovec) * iov_to_batch);
166	fio_batch_add(batch, iov_to_batch);	4,189,530✔
167	iov_pos += iov_to_batch;	4,189,530✔
168	while (batch->iovcnt) {	8,379,070✔
169	ssize_t written = fio_batch_write(batch, fd);	4,189,530✔
170	if (written < 0) {	4,189,530!
171	fio_batch_delete(batch);
172	return -1;	×
173	}
174	nwr += written;	4,189,530✔
175	}
176	}
177	fio_batch_delete(batch);	4,189,540✔
178	return nwr;	4,189,540✔
179	}
180
181	off_t
182	fio_lseek(int fd, off_t offset, int whence)	1,474✔
183	{
184	off_t effective_offset = lseek(fd, offset, whence);	1,474✔
185
186	if (effective_offset == -1) {	1,474!
187	say_syserror("lseek, [%s]: offset=%jd, whence=%d",	×
188	fio_filename(fd), (intmax_t) offset, whence);
189	} else if (whence == SEEK_SET && effective_offset != offset) {	1,474!
190	say_error("lseek, [%s]: offset set to unexpected value: "	×
191	"requested %jd effective %jd",
192	fio_filename(fd),
193	(intmax_t)offset, (intmax_t)effective_offset);
194	}
195	return effective_offset;	1,474✔
196	}
197
198	int
199	fio_truncate(int fd, off_t offset)	×
200	{
201	int rc = ftruncate(fd, offset);	×
202	if (rc)	×
203	say_syserror("fio_truncate, [%s]: offset=%jd",	×
204	fio_filename(fd), (intmax_t) offset);
205	return rc;	×
206	}
207
208
209	struct fio_batch *
210	fio_batch_new(void)	4,189,530✔
211	{
212	int max_iov = sysconf(_SC_IOV_MAX);	4,189,530✔
213	if (max_iov < 1)	4,189,530!
214	max_iov = IOV_MAX;	×
215
216	struct fio_batch batch = (struct fio_batch )
217	malloc(sizeof(struct fio_batch) +	4,189,530✔
218	sizeof(struct iovec) * max_iov);
219	if (batch == NULL)	4,189,530!
220	return NULL;	×
221
222	fio_batch_reset(batch);	4,189,530✔
223	batch->max_iov = max_iov;	4,189,530✔
224	return batch;	4,189,530✔
225	}
226
227	void
228	fio_batch_delete(struct fio_batch *batch)	4,189,530✔
229	{
230	free(batch);	4,189,530✔
231	}	4,189,530✔
232
233	size_t
234	fio_batch_add(struct fio_batch *batch, int count)	4,189,530✔
235	{
236	assert(batch->iovcnt + count <= batch->max_iov);	4,189,530!
237
238	size_t total_bytes = 0;	4,189,530✔
239	struct iovec *iov = batch->iov + batch->iovcnt;	4,189,530✔
240	struct iovec *end = iov + count;	4,189,530✔
241	for (; iov != end; ++iov) {	8,379,800✔
242	assert(iov->iov_base != NULL && iov->iov_len > 0);	4,190,270!
243	total_bytes += iov->iov_len;	4,190,270✔
244	}
245	batch->iovcnt += count;	4,189,530✔
246	batch->bytes += total_bytes;	4,189,530✔
247	return total_bytes;	4,189,530✔
248	}
249
250	/**
251	* Rotate batch after partial write.
252	*/
253	static inline void
254	fio_batch_rotate(struct fio_batch *batch, size_t bytes_written)	4,189,540✔
255	{
256	/*
257	* writev(2) usually fully write all data on local filesystems.
258	*/
259	if (likely(bytes_written == batch->bytes)) {	4,189,540!
260	/* Full write */
261	fio_batch_reset(batch);	4,189,540✔
262	return;	4,189,530✔
263	}
264
265	assert(bytes_written < batch->bytes); /* Partial write */	×
266	batch->bytes -= bytes_written;	×
267
268	struct iovec *iov = batch->iov;	×
269	struct iovec *iovend = iov + batch->iovcnt;	×
270	for (; iov < iovend; ++iov) {	×
271	if (iov->iov_len > bytes_written) {	×
272	iov->iov_base = (char *) iov->iov_base + bytes_written;	×
273	iov->iov_len -= bytes_written;	×
274	break;	×
275	}
276	bytes_written -= iov->iov_len;	×
277	}
278	assert(iov < iovend); /* Partial write */	×
279	memmove(batch->iov, iov, (iovend - iov) * sizeof(struct iovec));	×
280	batch->iovcnt = iovend - iov;	×
281	}
282
283	ssize_t
284	fio_batch_write(struct fio_batch *batch, int fd)	4,189,530✔
285	{
286	ssize_t bytes_written = fio_writev(fd, batch->iov, batch->iovcnt);	4,189,530✔
287	if (unlikely(bytes_written <= 0))	4,189,540!
288	return -1; /* Error */	×
289
290	fio_batch_rotate(batch, bytes_written);	4,189,540✔
291	return bytes_written;	4,189,530✔
292	}

tarantool / tarantool / 12180976347

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous