14271

pending completion

Build # 14271

Build Type

push

travis-ci

Committed by

locker

Commit Message

<a href="https://github.com/tarantool/tarantool/commit/<a class=hub.com/tarantool/tarantool/commit/55dcde00d15553c897fc99f1e24124a4393c453b">55dcde00d<a href="https://github.com/tarantool/tarantool/commit/55dcde00d15553c897fc99f1e24124a4393c453b">&quot;&gt;xlog: fix sync_is_async xlog option

The behaviour change was introduced in cda3cb55: sync_is_async option
was forgotten to be updated from xdir; sync_interval was forgotten too,
but was restored in 1900c58b.

The commit fixes the performance regression around 6-14% for average RPS
on default nosqlbench workload with 30 seconds duration. The additional
information about benchmarking can be found in #3747.

Thanks to Vladimir Davydov (@locker) for the investigation of the
cda3cb55 changes.

Closes #3747

(cherry picked from commit </a><a class="double-link" href="https://github.com/tarantool/tarantool/commit/<a class="double-link" href="https://github.com/tarantool/tarantool/commit/cd9cc4c5057581970db4f8107c2a86ff0b24f4e2">cd9cc4c50</a>">cd9cc4c50</a><a href="https://github.com/tarantool/tarantool/commit/55dcde00d15553c897fc99f1e24124a4393c453b">)

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

40853 of 49760 relevant lines covered (82.1%)

857679.19 hits per line

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

48.57

/src/backtrace.cc

/*
 * 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 "backtrace.h"
#include "trivia/util.h"

#include <stdlib.h>
#include <stdio.h>

#include <cxxabi.h>

#include "say.h"
#include "fiber.h"

#include "assoc.h"

#define CRLF "\n"

#ifdef ENABLE_BACKTRACE
#include <libunwind.h>

#include "small/region.h"
/*
 * We use a global static buffer because it is too late to do any
 * allocation when we are printing backtrace and fiber stack is
 * small.
 */

#define BACKTRACE_NAME_MAX 200

static char backtrace_buf[4096 * 4];

static __thread struct region cache_region;
static __thread struct mh_i64ptr_t *proc_cache = NULL;

struct proc_cache_entry {
        char name[BACKTRACE_NAME_MAX];
        unw_word_t offset;
};

void
backtrace_proc_cache_clear()
{
        if (proc_cache == NULL)
                return;
        region_destroy(&cache_region);
        mh_i64ptr_delete(proc_cache);
        proc_cache = NULL;
}

const char *
get_proc_name(unw_cursor_t *unw_cur, unw_word_t *offset, bool skip_cache)
{
        static __thread char proc_name[BACKTRACE_NAME_MAX];
        unw_word_t ip;
        unw_get_reg(unw_cur, UNW_REG_IP, &ip);

        if (skip_cache) {
                unw_get_proc_name(unw_cur, proc_name, sizeof(proc_name),
                                  offset);
                return proc_name;
        }

        struct proc_cache_entry *entry;
        struct mh_i64ptr_node_t node;
        mh_int_t k;

        if (proc_cache == NULL) {
                region_create(&cache_region, &cord()->slabc);
                proc_cache = mh_i64ptr_new();
                if (proc_cache == NULL) {
                        unw_get_proc_name(unw_cur, proc_name, sizeof(proc_name),
                                          offset);
                        goto error;
                }
        }

        k  = mh_i64ptr_find(proc_cache, ip, NULL);
        if (k != mh_end(proc_cache)) {
                entry = (struct proc_cache_entry *)
                        mh_i64ptr_node(proc_cache, k)->val;
                snprintf(proc_name, BACKTRACE_NAME_MAX, "%s", entry->name);
                *offset = entry->offset;
        }  else {
                unw_get_proc_name(unw_cur, proc_name, sizeof(proc_name),
                                  offset);

                entry = (struct proc_cache_entry *)
                        region_alloc(&cache_region, sizeof(struct proc_cache_entry));
                if (entry == NULL)
                        goto error;
                node.key = ip;
                node.val = entry;
                snprintf(entry->name, BACKTRACE_NAME_MAX, "%s", proc_name);
                entry->offset = *offset;

                k = mh_i64ptr_put(proc_cache, &node, NULL, NULL);
                if (k == mh_end(proc_cache)) {
                        free(entry);
                        goto error;
                }
        }
error:
        return proc_name;
}

char *
backtrace()
{
        int frame_no = 0;
        unw_word_t sp = 0, old_sp = 0, ip, offset;
        unw_context_t unw_context;
        unw_getcontext(&unw_context);
        unw_cursor_t unw_cur;
        unw_init_local(&unw_cur, &unw_context);
        char *p = backtrace_buf;
        char *end = p + sizeof(backtrace_buf) - 1;
        int unw_status;
        while ((unw_status = unw_step(&unw_cur)) > 0) {
                const char *proc;
                old_sp = sp;
                unw_get_reg(&unw_cur, UNW_REG_IP, &ip);
                unw_get_reg(&unw_cur, UNW_REG_SP, &sp);
                if (sp == old_sp) {
                        say_debug("unwinding error: previous frame "
                                  "identical to this frame (corrupt stack?)");
                        goto out;
                }
                proc = get_proc_name(&unw_cur, &offset, true);
                p += snprintf(p, end - p, "#%-2d %p in ", frame_no, (void *)ip);
                if (p >= end)
                        goto out;
                p += snprintf(p, end - p, "%s+%lx", proc, (long)offset);
                if (p >= end)
                        goto out;
                p += snprintf(p, end - p, CRLF);
                if (p >= end)
                        goto out;
                ++frame_no;
        }
#ifndef TARGET_OS_DARWIN
        if (unw_status != 0)
                say_debug("unwinding error: %s", unw_strerror(unw_status));
#else
        if (unw_status != 0)
                say_debug("unwinding error: %i", unw_status);
#endif
out:
        *p = '\0';
        return backtrace_buf;
}

/*
 * Libunwind unw_getcontext wrapper.
 * unw_getcontext can be a macros on some platform and can not be called
 * directly from asm code. Stack variable pass through the wrapper to
 * preserve a old stack pointer during the wrapper call.
 *
 * @param unw_context unwind context to store execution state
 * @param stack pointer to preserve.
 * @retval preserved stack pointer.
 */
static void *
unw_getcontext_f(unw_context_t *unw_context, void *stack)
{
        unw_getcontext(unw_context);
        return stack;
}

/*
 * Restore target coro context and call unw_getcontext over it.
 * Work is done in four parts:
 * 1. Save current fiber context to a stack and save a stack pointer
 * 2. Restore target fiber context, stack pointer is not incremented because
 *    all target stack context should be preserved across a call. No stack
 *    changes are allowed until unwinding is done.
 * 3. Setup new stack frame and call unw_getcontext wrapper. All callee-safe
 *    registers are used by target fiber context, so old stack pointer is
 *    passed as second arg to wrapper func.
 * 4. Restore old stack pointer from wrapper return and restore old fiber
 *    contex.
 *
 * @param @unw_context unwind context to store execution state.
 * @param @coro_ctx fiber context to unwind.
 */
static void
coro_unwcontext(unw_context_t *unw_context, struct coro_context *coro_ctx)
{
#if __amd64
__asm__ volatile(
        /* Preserve current context */
        "\tpushq %%rbp\n"
        "\tpushq %%rbx\n"
        "\tpushq %%r12\n"
        "\tpushq %%r13\n"
        "\tpushq %%r14\n"
        "\tpushq %%r15\n"
        /* Setup second arg as old sp */
        "\tmovq %%rsp, %%rsi\n"
        /* Restore target context, but not increment sp to preserve it */
        "\tmovq 0(%1), %%rsp\n"
        "\tmovq 0(%%rsp), %%r15\n"
        "\tmovq 8(%%rsp), %%r14\n"
        "\tmovq 16(%%rsp), %%r13\n"
        "\tmovq 24(%%rsp), %%r12\n"
        "\tmovq 32(%%rsp), %%rbx\n"
        "\tmovq 40(%%rsp), %%rbp\n"
        /* Set first arg and call */
        "\tmovq %0, %%rdi\n"
#ifdef TARGET_OS_DARWIN
        "\tandq $0xfffffffffffffff0, %%rsp\n"
#endif
        "\tleaq %P2(%%rip), %%rax\n"
        "\tcall *%%rax\n"
        /* Restore old sp and context */
        "\tmov %%rax, %%rsp\n"
        "\tpopq %%r15\n"
        "\tpopq %%r14\n"
        "\tpopq %%r13\n"
        "\tpopq %%r12\n"
        "\tpopq %%rbx\n"
        "\tpopq %%rbp\n"
        :
        : "r" (unw_context), "r" (coro_ctx), "i" (unw_getcontext_f)
        : "rdi", "rsi", "rax"//, "r8"//"rsp", "r11", "r10", "r9", "r8"
        );

#elif __i386
__asm__ volatile(
        /* Save current context */
        "\tpushl %%ebp\n"
        "\tpushl %%ebx\n"
        "\tpushl %%esi\n"
        "\tpushl %%edi\n"
        /* Setup second arg as old sp */
        "\tmovl %%esp, %%ecx\n"
        /* Restore target context ,but not increment sp to preserve it */
        "\tmovl (%1), %%esp\n"
        "\tmovl 0(%%esp), %%edi\n"
        "\tmovl 4(%%esp), %%esi\n"
        "\tmovl 8(%%esp), %%ebx\n"
        "\tmovl 12(%%esp), %%ebp\n"
        /* Setup first arg and call */
        "\tpushl %%ecx\n"
        "\tpushl %0\n"
        "\tmovl %2, %%ecx\n"
        "\tcall *%%ecx\n"
        /* Restore old sp and context */
        "\tmovl %%eax, %%esp\n"
        "\tpopl %%edi\n"
        "\tpopl %%esi\n"
        "\tpopl %%ebx\n"
        "\tpopl %%ebp\n"
        :
        : "r" (unw_context), "r" (coro_ctx), "i" (unw_getcontext_f)
        : "ecx", "eax"
        );

#elif __ARM_ARCH==7
__asm__ volatile(
        /* Save current context */
        ".syntax unified\n"
        "\tvpush {d8-d15}\n"
        "\tpush {r4-r11,lr}\n"
        /* Save sp */
        "\tmov r1, sp\n"
        /* Restore target context, but not increment sp to preserve it */
        "\tldr sp, [%1]\n"
        "\tldmia sp, {r4-r11,lr}\n"
        "\tvldmia sp, {d8-d15}\n"
        /* Setup first arg */
        "\tmov r0, %0\n"
        /* Setup stack frame */
        "\tpush {r7, lr}\n"
        "\tsub sp, #8\n"
        "\tstr r0, [sp, #4]\n"
        "\tstr r1, [sp, #0]\n"
        "\tmov r7, sp\n"
        "\tbl %2\n"
        /* Old sp is returned via r0 */
        "\tmov sp, r0\n"
        "\tpop {r4-r11,lr}\n"
        "\tvpop {d8-d15}\n"
        :
        : "r" (unw_context), "r" (coro_ctx), "i" (unw_getcontext_f)
        : "lr", "r0", "r1", "ip"
        );

#elif __aarch64__
__asm__ volatile(
        /* Save current context */
        "\tsub x1, sp, #8 * 20\n"
        "\tstp x19, x20, [x1, #16 * 0]\n"
        "\tstp x21, x22, [x1, #16 * 1]\n"
        "\tstp x23, x24, [x1, #16 * 2]\n"
        "\tstp x25, x26, [x1, #16 * 3]\n"
        "\tstp x27, x28, [x1, #16 * 4]\n"
        "\tstp x29, x30, [x1, #16 * 5]\n"
        "\tstp d8,  d9,  [x1, #16 * 6]\n"
        "\tstp d10, d11, [x1, #16 * 7]\n"
        "\tstp d12, d13, [x1, #16 * 8]\n"
        "\tstp d14, d15, [x1, #16 * 9]\n"
        /* Restore target context */
        "\tldr x2, [%1]\n"
        "\tldp x19, x20, [x2, #16 * 0]\n"
        "\tldp x21, x22, [x2, #16 * 1]\n"
        "\tldp x23, x24, [x2, #16 * 2]\n"
        "\tldp x25, x26, [x2, #16 * 3]\n"
        "\tldp x27, x28, [x2, #16 * 4]\n"
        "\tldp x29, x30, [x2, #16 * 5]\n"
        "\tldp d8,  d9,  [x2, #16 * 6]\n"
        "\tldp d10, d11, [x2, #16 * 7]\n"
        "\tldp d12, d13, [x2, #16 * 8]\n"
        "\tldp d14, d15, [x2, #16 * 9]\n"
        "\tmov sp, x2\n"
        /* Setup fisrst arg */
        "\tmov x0, %0\n"
        "\tbl %2\n"
        /* Restore context (old sp in x0) */
        "\tldp x19, x20, [x0, #16 * 0]\n"
        "\tldp x21, x22, [x0, #16 * 1]\n"
        "\tldp x23, x24, [x0, #16 * 2]\n"
        "\tldp x25, x26, [x0, #16 * 3]\n"
        "\tldp x27, x28, [x0, #16 * 4]\n"
        "\tldp x29, x30, [x0, #16 * 5]\n"
        "\tldp d8,  d9,  [x0, #16 * 6]\n"
        "\tldp d10, d11, [x0, #16 * 7]\n"
        "\tldp d12, d13, [x0, #16 * 8]\n"
        "\tldp d14, d15, [x0, #16 * 9]\n"
        "\tadd sp, x0, #8 * 20\n"
        :
        : "r" (unw_context), "r" (coro_ctx), "i" (unw_getcontext_f)
        : /*"lr", "r0", "r1", "ip" */
         "x0", "x1", "x2", "x30"
        );
#endif
}

void
backtrace_foreach(backtrace_cb cb, coro_context *coro_ctx, void *cb_ctx)
{
        unw_cursor_t unw_cur;
        unw_context_t unw_ctx;
        coro_unwcontext(&unw_ctx, coro_ctx);
        unw_init_local(&unw_cur, &unw_ctx);
        int frame_no = 0;
        unw_word_t sp = 0, old_sp = 0, ip, offset;
        int unw_status, demangle_status;
        char *demangle_buf = NULL;
        size_t demangle_buf_len = 0;

        while ((unw_status = unw_step(&unw_cur)) > 0) {
                const char *proc;
                old_sp = sp;
                unw_get_reg(&unw_cur, UNW_REG_IP, &ip);
                unw_get_reg(&unw_cur, UNW_REG_SP, &sp);
                if (sp == old_sp) {
                        say_debug("unwinding error: previous frame "
                                  "identical to this frame (corrupt stack?)");
                        goto out;
                }
                proc = get_proc_name(&unw_cur, &offset, false);

                char *cxxname = abi::__cxa_demangle(proc, demangle_buf,
                                                    &demangle_buf_len,
                                                    &demangle_status);
                if (cxxname != NULL)
                        demangle_buf = cxxname;
                if (frame_no > 0 &&
                    (cb(frame_no - 1, (void *)ip, cxxname != NULL ? cxxname : proc,
                        offset, cb_ctx) != 0))
                        goto out;
                ++frame_no;
        }
#ifndef TARGET_OS_DARWIN
        if (unw_status != 0)
                say_debug("unwinding error: %s", unw_strerror(unw_status));
#else
        if (unw_status != 0)
                say_debug("unwinding error: %i", unw_status);
#endif
out:
        free(demangle_buf);
}

void
print_backtrace()
{
        fdprintf(STDERR_FILENO, "%s", backtrace());
}
#endif /* ENABLE_BACKTRACE */


NORETURN void
assert_fail(const char *assertion, const char *file, unsigned int line, const char *function)
{
        fprintf(stderr, "%s:%i: %s: assertion %s failed.\n", file, line, function, assertion);
#ifdef ENABLE_BACKTRACE
        print_backtrace();
#endif /* ENABLE_BACKTRACE */
        close_all_xcpt(0);
        abort();
}


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 "backtrace.h"
32	#include "trivia/util.h"
33
34	#include <stdlib.h>
35	#include <stdio.h>
36
37	#include <cxxabi.h>
38
39	#include "say.h"
40	#include "fiber.h"
41
42	#include "assoc.h"
43
44	#define CRLF "\n"
45
46	#ifdef ENABLE_BACKTRACE
47	#include <libunwind.h>
48
49	#include "small/region.h"
50	/*
51	* We use a global static buffer because it is too late to do any
52	* allocation when we are printing backtrace and fiber stack is
53	* small.
54	*/
55
56	#define BACKTRACE_NAME_MAX 200
57
58	static char backtrace_buf[4096 * 4];
59
60	static __thread struct region cache_region;
61	static __thread struct mh_i64ptr_t *proc_cache = NULL;
62
63	struct proc_cache_entry {
64	char name[BACKTRACE_NAME_MAX];
65	unw_word_t offset;
66	};
67
68	void
69	backtrace_proc_cache_clear()	×
70	{
71	if (proc_cache == NULL)	×
72	return;	×
73	region_destroy(&cache_region);	×
74	mh_i64ptr_delete(proc_cache);	×
75	proc_cache = NULL;	×
76	}
77
78	const char *
79	get_proc_name(unw_cursor_t unw_cur, unw_word_t offset, bool skip_cache)	704✔
80	{
81	static __thread char proc_name[BACKTRACE_NAME_MAX];
82	unw_word_t ip;
83	unw_get_reg(unw_cur, UNW_REG_IP, &ip);	704✔
84
85	if (skip_cache) {	704✔
86	unw_get_proc_name(unw_cur, proc_name, sizeof(proc_name),
87	offset);	×
88	return proc_name;	×
89	}
90
91	struct proc_cache_entry *entry;
92	struct mh_i64ptr_node_t node;
93	mh_int_t k;
94
95	if (proc_cache == NULL) {	704✔
96	region_create(&cache_region, &cord()->slabc);	2✔
97	proc_cache = mh_i64ptr_new();	2✔
98	if (proc_cache == NULL) {	2✔
99	unw_get_proc_name(unw_cur, proc_name, sizeof(proc_name),
100	offset);	×
101	goto error;	×
102	}
103	}
104
105	k = mh_i64ptr_find(proc_cache, ip, NULL);	704✔
106	if (k != mh_end(proc_cache)) {	704✔
107	entry = (struct proc_cache_entry *)	661✔
108	mh_i64ptr_node(proc_cache, k)->val;	661✔
109	snprintf(proc_name, BACKTRACE_NAME_MAX, "%s", entry->name);	661✔
110	*offset = entry->offset;	661✔
111	} else {
112	unw_get_proc_name(unw_cur, proc_name, sizeof(proc_name),
113	offset);	43✔
114
115	entry = (struct proc_cache_entry *)
116	region_alloc(&cache_region, sizeof(struct proc_cache_entry));	43✔
117	if (entry == NULL)	43✔
118	goto error;	×
119	node.key = ip;	43✔
120	node.val = entry;	43✔
121	snprintf(entry->name, BACKTRACE_NAME_MAX, "%s", proc_name);	43✔
122	entry->offset = *offset;	43✔
123
124	k = mh_i64ptr_put(proc_cache, &node, NULL, NULL);	43✔
125	if (k == mh_end(proc_cache)) {	43✔
126	free(entry);	×
127	goto error;	×
128	}
129	}
130	error:
131	return proc_name;	704✔
132	}
133
134	char *
135	backtrace()	×
136	{
137	int frame_no = 0;	×
138	unw_word_t sp = 0, old_sp = 0, ip, offset;	×
139	unw_context_t unw_context;
140	unw_getcontext(&unw_context);	×
141	unw_cursor_t unw_cur;
142	unw_init_local(&unw_cur, &unw_context);	×
143	char *p = backtrace_buf;	×
144	char *end = p + sizeof(backtrace_buf) - 1;	×
145	int unw_status;
146	while ((unw_status = unw_step(&unw_cur)) > 0) {	×
147	const char *proc;
148	old_sp = sp;	×
149	unw_get_reg(&unw_cur, UNW_REG_IP, &ip);	×
150	unw_get_reg(&unw_cur, UNW_REG_SP, &sp);	×
151	if (sp == old_sp) {	×
152	say_debug("unwinding error: previous frame "	×
153	"identical to this frame (corrupt stack?)");
154	goto out;	×
155	}
156	proc = get_proc_name(&unw_cur, &offset, true);	×
157	p += snprintf(p, end - p, "#%-2d %p in ", frame_no, (void *)ip);	×
158	if (p >= end)	×
159	goto out;	×
160	p += snprintf(p, end - p, "%s+%lx", proc, (long)offset);	×
161	if (p >= end)	×
162	goto out;	×
163	p += snprintf(p, end - p, CRLF);	×
164	if (p >= end)	×
165	goto out;	×
166	++frame_no;	×
167	}
168	#ifndef TARGET_OS_DARWIN
169	if (unw_status != 0)	×
170	say_debug("unwinding error: %s", unw_strerror(unw_status));	×
171	#else
172	if (unw_status != 0)
173	say_debug("unwinding error: %i", unw_status);
174	#endif
175	out:
176	*p = '\0';	×
177	return backtrace_buf;	×
178	}
179
180	/*
181	* Libunwind unw_getcontext wrapper.
182	* unw_getcontext can be a macros on some platform and can not be called
183	* directly from asm code. Stack variable pass through the wrapper to
184	* preserve a old stack pointer during the wrapper call.
185	*
186	* @param unw_context unwind context to store execution state
187	* @param stack pointer to preserve.
188	* @retval preserved stack pointer.
189	*/
190	static void *
191	unw_getcontext_f(unw_context_t unw_context, void stack)	63✔
192	{
193	unw_getcontext(unw_context);	63✔
194	return stack;	63✔
195	}
196
197	/*
198	* Restore target coro context and call unw_getcontext over it.
199	* Work is done in four parts:
200	* 1. Save current fiber context to a stack and save a stack pointer
201	* 2. Restore target fiber context, stack pointer is not incremented because
202	* all target stack context should be preserved across a call. No stack
203	* changes are allowed until unwinding is done.
204	* 3. Setup new stack frame and call unw_getcontext wrapper. All callee-safe
205	* registers are used by target fiber context, so old stack pointer is
206	* passed as second arg to wrapper func.
207	* 4. Restore old stack pointer from wrapper return and restore old fiber
208	* contex.
209	*
210	* @param @unw_context unwind context to store execution state.
211	* @param @coro_ctx fiber context to unwind.
212	*/
213	static void
214	coro_unwcontext(unw_context_t unw_context, struct coro_context coro_ctx)	63✔
215	{
216	#if __amd64
217	__asm__ volatile(
218	/* Preserve current context */
219	"\tpushq %%rbp\n"
220	"\tpushq %%rbx\n"
221	"\tpushq %%r12\n"
222	"\tpushq %%r13\n"
223	"\tpushq %%r14\n"
224	"\tpushq %%r15\n"
225	/* Setup second arg as old sp */
226	"\tmovq %%rsp, %%rsi\n"
227	/* Restore target context, but not increment sp to preserve it */
228	"\tmovq 0(%1), %%rsp\n"
229	"\tmovq 0(%%rsp), %%r15\n"
230	"\tmovq 8(%%rsp), %%r14\n"
231	"\tmovq 16(%%rsp), %%r13\n"
232	"\tmovq 24(%%rsp), %%r12\n"
233	"\tmovq 32(%%rsp), %%rbx\n"
234	"\tmovq 40(%%rsp), %%rbp\n"
235	/* Set first arg and call */
236	"\tmovq %0, %%rdi\n"
237	#ifdef TARGET_OS_DARWIN
238	"\tandq $0xfffffffffffffff0, %%rsp\n"
239	#endif
240	"\tleaq %P2(%%rip), %%rax\n"
241	"\tcall *%%rax\n"
242	/* Restore old sp and context */
243	"\tmov %%rax, %%rsp\n"
244	"\tpopq %%r15\n"
245	"\tpopq %%r14\n"
246	"\tpopq %%r13\n"
247	"\tpopq %%r12\n"
248	"\tpopq %%rbx\n"
249	"\tpopq %%rbp\n"
250	:
251	: "r" (unw_context), "r" (coro_ctx), "i" (unw_getcontext_f)
252	: "rdi", "rsi", "rax"//, "r8"//"rsp", "r11", "r10", "r9", "r8"
253	);	63✔
254
255	#elif __i386
256	__asm__ volatile(
257	/* Save current context */
258	"\tpushl %%ebp\n"
259	"\tpushl %%ebx\n"
260	"\tpushl %%esi\n"
261	"\tpushl %%edi\n"
262	/* Setup second arg as old sp */
263	"\tmovl %%esp, %%ecx\n"
264	/* Restore target context ,but not increment sp to preserve it */
265	"\tmovl (%1), %%esp\n"
266	"\tmovl 0(%%esp), %%edi\n"
267	"\tmovl 4(%%esp), %%esi\n"
268	"\tmovl 8(%%esp), %%ebx\n"
269	"\tmovl 12(%%esp), %%ebp\n"
270	/* Setup first arg and call */
271	"\tpushl %%ecx\n"
272	"\tpushl %0\n"
273	"\tmovl %2, %%ecx\n"
274	"\tcall *%%ecx\n"
275	/* Restore old sp and context */
276	"\tmovl %%eax, %%esp\n"
277	"\tpopl %%edi\n"
278	"\tpopl %%esi\n"
279	"\tpopl %%ebx\n"
280	"\tpopl %%ebp\n"
281	:
282	: "r" (unw_context), "r" (coro_ctx), "i" (unw_getcontext_f)
283	: "ecx", "eax"
284	);
285
286	#elif __ARM_ARCH==7
287	__asm__ volatile(
288	/* Save current context */
289	".syntax unified\n"
290	"\tvpush {d8-d15}\n"
291	"\tpush {r4-r11,lr}\n"
292	/* Save sp */
293	"\tmov r1, sp\n"
294	/* Restore target context, but not increment sp to preserve it */
295	"\tldr sp, [%1]\n"
296	"\tldmia sp, {r4-r11,lr}\n"
297	"\tvldmia sp, {d8-d15}\n"
298	/* Setup first arg */
299	"\tmov r0, %0\n"
300	/* Setup stack frame */
301	"\tpush {r7, lr}\n"
302	"\tsub sp, #8\n"
303	"\tstr r0, [sp, #4]\n"
304	"\tstr r1, [sp, #0]\n"
305	"\tmov r7, sp\n"
306	"\tbl %2\n"
307	/* Old sp is returned via r0 */
308	"\tmov sp, r0\n"
309	"\tpop {r4-r11,lr}\n"
310	"\tvpop {d8-d15}\n"
311	:
312	: "r" (unw_context), "r" (coro_ctx), "i" (unw_getcontext_f)
313	: "lr", "r0", "r1", "ip"
314	);
315
316	#elif __aarch64__
317	__asm__ volatile(
318	/* Save current context */
319	"\tsub x1, sp, #8 * 20\n"
320	"\tstp x19, x20, [x1, #16 * 0]\n"
321	"\tstp x21, x22, [x1, #16 * 1]\n"
322	"\tstp x23, x24, [x1, #16 * 2]\n"
323	"\tstp x25, x26, [x1, #16 * 3]\n"
324	"\tstp x27, x28, [x1, #16 * 4]\n"
325	"\tstp x29, x30, [x1, #16 * 5]\n"
326	"\tstp d8, d9, [x1, #16 * 6]\n"
327	"\tstp d10, d11, [x1, #16 * 7]\n"
328	"\tstp d12, d13, [x1, #16 * 8]\n"
329	"\tstp d14, d15, [x1, #16 * 9]\n"
330	/* Restore target context */
331	"\tldr x2, [%1]\n"
332	"\tldp x19, x20, [x2, #16 * 0]\n"
333	"\tldp x21, x22, [x2, #16 * 1]\n"
334	"\tldp x23, x24, [x2, #16 * 2]\n"
335	"\tldp x25, x26, [x2, #16 * 3]\n"
336	"\tldp x27, x28, [x2, #16 * 4]\n"
337	"\tldp x29, x30, [x2, #16 * 5]\n"
338	"\tldp d8, d9, [x2, #16 * 6]\n"
339	"\tldp d10, d11, [x2, #16 * 7]\n"
340	"\tldp d12, d13, [x2, #16 * 8]\n"
341	"\tldp d14, d15, [x2, #16 * 9]\n"
342	"\tmov sp, x2\n"
343	/* Setup fisrst arg */
344	"\tmov x0, %0\n"
345	"\tbl %2\n"
346	/* Restore context (old sp in x0) */
347	"\tldp x19, x20, [x0, #16 * 0]\n"
348	"\tldp x21, x22, [x0, #16 * 1]\n"
349	"\tldp x23, x24, [x0, #16 * 2]\n"
350	"\tldp x25, x26, [x0, #16 * 3]\n"
351	"\tldp x27, x28, [x0, #16 * 4]\n"
352	"\tldp x29, x30, [x0, #16 * 5]\n"
353	"\tldp d8, d9, [x0, #16 * 6]\n"
354	"\tldp d10, d11, [x0, #16 * 7]\n"
355	"\tldp d12, d13, [x0, #16 * 8]\n"
356	"\tldp d14, d15, [x0, #16 * 9]\n"
357	"\tadd sp, x0, #8 * 20\n"
358	:
359	: "r" (unw_context), "r" (coro_ctx), "i" (unw_getcontext_f)
360	: /"lr", "r0", "r1", "ip" /
361	"x0", "x1", "x2", "x30"
362	);
363	#endif
364	}	63✔
365
366	void
367	backtrace_foreach(backtrace_cb cb, coro_context coro_ctx, void cb_ctx)	63✔
368	{
369	unw_cursor_t unw_cur;
370	unw_context_t unw_ctx;
371	coro_unwcontext(&unw_ctx, coro_ctx);	63✔
372	unw_init_local(&unw_cur, &unw_ctx);	63✔
373	int frame_no = 0;	63✔
374	unw_word_t sp = 0, old_sp = 0, ip, offset;	63✔
375	int unw_status, demangle_status;
376	char *demangle_buf = NULL;	63✔
377	size_t demangle_buf_len = 0;	63✔
378
379	while ((unw_status = unw_step(&unw_cur)) > 0) {	1,471✔
380	const char *proc;
381	old_sp = sp;	704✔
382	unw_get_reg(&unw_cur, UNW_REG_IP, &ip);	704✔
383	unw_get_reg(&unw_cur, UNW_REG_SP, &sp);	704✔
384	if (sp == old_sp) {	704✔
385	say_debug("unwinding error: previous frame "	×
386	"identical to this frame (corrupt stack?)");
387	goto out;	×
388	}
389	proc = get_proc_name(&unw_cur, &offset, false);	704✔
390
391	char *cxxname = abi::__cxa_demangle(proc, demangle_buf,
392	&demangle_buf_len,
393	&demangle_status);	704✔
394	if (cxxname != NULL)	704✔
395	demangle_buf = cxxname;	126✔
396	if (frame_no > 0 &&	1,345✔
397	(cb(frame_no - 1, (void *)ip, cxxname != NULL ? cxxname : proc,	641✔
398	offset, cb_ctx) != 0))
399	goto out;	×
400	++frame_no;	704✔
401	}
402	#ifndef TARGET_OS_DARWIN
403	if (unw_status != 0)	63✔
404	say_debug("unwinding error: %s", unw_strerror(unw_status));	×
405	#else
406	if (unw_status != 0)
407	say_debug("unwinding error: %i", unw_status);
408	#endif
409	out:
410	free(demangle_buf);	63✔
411	}	63✔
412
413	void
414	print_backtrace()	×
415	{
416	fdprintf(STDERR_FILENO, "%s", backtrace());	×
417	}	×
418	#endif /* ENABLE_BACKTRACE */
419
420
421	NORETURN void
422	assert_fail(const char assertion, const char file, unsigned int line, const char *function)	×
423	{
424	fprintf(stderr, "%s:%i: %s: assertion %s failed.\n", file, line, function, assertion);	×
425	#ifdef ENABLE_BACKTRACE
426	print_backtrace();	×
427	#endif /* ENABLE_BACKTRACE */
428	close_all_xcpt(0);	×
429	abort();	×
430	}
431

tarantool / tarantool / 14271

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