11029368633

Committed 25 Sep 2024 08:33AM UTC coverage: 85.914% (+0.009%) from 85.905%

Build # 11029368633

Build Type

push

github

Committed by

locker

Commit Message

vinyl: fix crash when empty PK DDL races with DML

Vinyl doesn't support altering the primary index of a non-empty space,
but the check forbidding this isn't entirely reliable - the DDL function
may yield to wait for pending WAL writes to finish after ensuring that
the space doesn't contain any tuples. If a new tuples is inserted into
the space in the meantime, the DDL operation will proceed rebuilding
the primary index and trigger a crash because the code is written on
the assumption that it's rebuilding a secondary index:

```
./src/box/vinyl.c:1572: vy_check_is_unique_secondary_one: Assertion `lsm->index_id > 0' failed.
```

Let's fix this by moving the check after syncing on WAL.

Closes #10603

NO_DOC=bug fix

(cherry picked from commit 955537b57)

Run Details

63052 of 114351 branches covered (55.14%)

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

16 existing lines in 8 files now uncovered.

93919 of 109317 relevant lines covered (85.91%)

3304184.31 hits per line

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

96.0

/src/lib/core/trigger.h

#ifndef TARANTOOL_LIB_CORE_TRIGGER_H_INCLUDED
#define TARANTOOL_LIB_CORE_TRIGGER_H_INCLUDED
/*
 * 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 "small/rlist.h"

#if defined(__cplusplus)
extern "C" {
#endif /* defined(__cplusplus) */
/**
 * Type of the callback which may be invoked
 * on an event.
 */
struct trigger;
typedef int (*trigger_f)(struct trigger *trigger, void *event);
typedef void (*trigger_f0)(struct trigger *trigger);

struct trigger
{
        /** A link in a list of all registered triggers. */
        struct rlist link;
        /** All execution lists which this trigger is part of. */
        struct rlist run_links;
        trigger_f run;
        /**
         * Lua ref in case the trigger is used in Lua,
         * or other trigger context.
         */
        void *data;
        /**
         * Cleanup function, called when the trigger is removed
         * or the object containing the trigger is destroyed.
         */
        trigger_f0 destroy;
};

#define TRIGGER_INITIALIZER(name, run) {\
        RLIST_LINK_INITIALIZER,\
        RLIST_HEAD_INITIALIZER((name).run_links),\
        (run),\
        NULL,\
        NULL\
}

#define TRIGGER(name, run)\
        struct trigger name = TRIGGER_INITIALIZER(name, run)

static inline void
trigger_create(struct trigger *trigger, trigger_f run, void *data,
               trigger_f0 destroy)
{
        rlist_create(&trigger->link);
        rlist_create(&trigger->run_links);
        trigger->run = run;
        trigger->data = data;
        trigger->destroy = destroy;
}

static inline void
trigger_add(struct rlist *list, struct trigger *trigger)
{
        /*
         * New triggers are pushed to the beginning of the list.
         * This ensures that they are not fired right away if
         * pushed from within a trigger. This also ensures that
         * the trigger which was set first is fired last.
         * Alter space code depends on this order.
         * @todo in future, allow triggers to be pushed
         * to an arbitrary position on the list.
         */
        rlist_add_entry(list, trigger, link);
}

static inline void
trigger_add_unique(struct rlist *list, struct trigger *trigger)
{
        struct trigger *trg;
        rlist_foreach_entry(trg, list, link) {
                if (trg->data == trigger->data && trg->run == trigger->run)
                        return;
        }
        trigger_add(list, trigger);
}

/** Remove the trigger from any list it's in. */
void
trigger_clear(struct trigger *trigger);

static inline void
trigger_destroy(struct rlist *list)
{
        struct trigger *trigger, *tmp;
        rlist_foreach_entry_safe(trigger, list, link, tmp) {
                trigger_clear(trigger);
                if (trigger->destroy)
                        trigger->destroy(trigger);
        }
}

/**
 * Run registered triggers. Stop and return an error if
 * a trigger fails.
 *
 * Note, since triggers are added to the list head, this
 * function first runs triggers that were added last
 */
int
trigger_run(struct rlist *list, void *event);

/**
 * Same as trigger_run(), but runs triggers in the reverse
 * order, i.e. it runs triggers in the same order they were
 * added.
 */
int
trigger_run_reverse(struct rlist *list, void *event);

/**
 * Runs registered triggers in fibers.
 * Note, since triggers are added to the list head, this
 * function first runs triggers that were added last. Waits
 * for their completion for a specified period of time.
 * If timeout has expired and function immediately stops,
 * without waiting for other triggers completion.
 */
int
trigger_fiber_run(struct rlist *list, void *event, double timeout);

/** Initialize the thread-dependent part of trigger subsystem. */
void
trigger_init_in_thread(void);

/** Free the thread-dependent part of trigger subsystem. */
void
trigger_free_in_thread(void);

#if defined(__cplusplus)
} /* extern "C" */

#include "diag.h"

static inline void
trigger_run_xc(struct rlist *list, void *event)
{
        if (trigger_run(list, event) != 0)
                diag_raise();
}

#endif /* defined(__cplusplus) */

#endif /* TARANTOOL_LIB_CORE_TRIGGER_H_INCLUDED */

1	#ifndef TARANTOOL_LIB_CORE_TRIGGER_H_INCLUDED
2	#define TARANTOOL_LIB_CORE_TRIGGER_H_INCLUDED
3	/*
4	* Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
5	*
6	* Redistribution and use in source and binary forms, with or
7	* without modification, are permitted provided that the following
8	* conditions are met:
9	*
10	* 1. Redistributions of source code must retain the above
11	* copyright notice, this list of conditions and the
12	* following disclaimer.
13	*
14	* 2. Redistributions in binary form must reproduce the above
15	* copyright notice, this list of conditions and the following
16	* disclaimer in the documentation and/or other materials
17	* provided with the distribution.
18	*
19	* THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
20	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
23	* <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
24	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30	* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31	* SUCH DAMAGE.
32	*/
33	#include "small/rlist.h"
34
35	#if defined(__cplusplus)
36	extern "C" {
37	#endif /* defined(__cplusplus) */
38	/**
39	* Type of the callback which may be invoked
40	* on an event.
41	*/
42	struct trigger;
43	typedef int (trigger_f)(struct trigger trigger, void *event);
44	typedef void (trigger_f0)(struct trigger trigger);
45
46	struct trigger
47	{
48	/** A link in a list of all registered triggers. */
49	struct rlist link;
50	/** All execution lists which this trigger is part of. */
51	struct rlist run_links;
52	trigger_f run;
53	/**
54	* Lua ref in case the trigger is used in Lua,
55	* or other trigger context.
56	*/
57	void *data;
58	/**
59	* Cleanup function, called when the trigger is removed
60	* or the object containing the trigger is destroyed.
61	*/
62	trigger_f0 destroy;
63	};
64
65	#define TRIGGER_INITIALIZER(name, run) {\
66	RLIST_LINK_INITIALIZER,\
67	RLIST_HEAD_INITIALIZER((name).run_links),\
68	(run),\
69	NULL,\
70	NULL\
71	}
72
73	#define TRIGGER(name, run)\
74	struct trigger name = TRIGGER_INITIALIZER(name, run)
75
76	static inline void
77	trigger_create(struct trigger trigger, trigger_f run, void data,	15,316,605✔
78	trigger_f0 destroy)
79	{
80	rlist_create(&trigger->link);	15,316,605✔
81	rlist_create(&trigger->run_links);	15,316,605✔
82	trigger->run = run;	15,316,605✔
83	trigger->data = data;	15,316,605✔
84	trigger->destroy = destroy;	15,316,605✔
85	}	15,316,605✔
86
87	static inline void
88	trigger_add(struct rlist list, struct trigger trigger)	20,937,373✔
89	{
90	/*
91	* New triggers are pushed to the beginning of the list.
92	* This ensures that they are not fired right away if
93	* pushed from within a trigger. This also ensures that
94	* the trigger which was set first is fired last.
95	* Alter space code depends on this order.
96	* @todo in future, allow triggers to be pushed
97	* to an arbitrary position on the list.
98	*/
99	rlist_add_entry(list, trigger, link);	20,937,373✔
100	}	20,937,373✔
101
102	static inline void
103	trigger_add_unique(struct rlist list, struct trigger trigger)	326✔
104	{
105	struct trigger *trg;
106	rlist_foreach_entry(trg, list, link) {	326✔
107	if (trg->data == trigger->data && trg->run == trigger->run)	10!
108	return;	10✔
109	}
110	trigger_add(list, trigger);	316✔
111	}
112
113	/** Remove the trigger from any list it's in. */
114	void
115	trigger_clear(struct trigger *trigger);
116
117	static inline void
118	trigger_destroy(struct rlist *list)	7,473,342✔
119	{
120	struct trigger trigger, tmp;
121	rlist_foreach_entry_safe(trigger, list, link, tmp) {	8,474,300!
122	trigger_clear(trigger);	500,478✔
123	if (trigger->destroy)	500,478✔
124	trigger->destroy(trigger);	26,252✔
125	}
126	}	7,473,342✔
127
128	/**
129	* Run registered triggers. Stop and return an error if
130	* a trigger fails.
131	*
132	* Note, since triggers are added to the list head, this
133	* function first runs triggers that were added last
134	*/
135	int
136	trigger_run(struct rlist list, void event);
137
138	/**
139	* Same as trigger_run(), but runs triggers in the reverse
140	* order, i.e. it runs triggers in the same order they were
141	* added.
142	*/
143	int
144	trigger_run_reverse(struct rlist list, void event);
145
146	/**
147	* Runs registered triggers in fibers.
148	* Note, since triggers are added to the list head, this
149	* function first runs triggers that were added last. Waits
150	* for their completion for a specified period of time.
151	* If timeout has expired and function immediately stops,
152	* without waiting for other triggers completion.
153	*/
154	int
155	trigger_fiber_run(struct rlist list, void event, double timeout);
156
157	/** Initialize the thread-dependent part of trigger subsystem. */
158	void
159	trigger_init_in_thread(void);
160
161	/** Free the thread-dependent part of trigger subsystem. */
162	void
163	trigger_free_in_thread(void);
164
165	#if defined(__cplusplus)
166	} /* extern "C" */
167
168	#include "diag.h"
169
170	static inline void
171	trigger_run_xc(struct rlist list, void event)	122,128✔
172	{
173	if (trigger_run(list, event) != 0)	122,128!
UNCOV 174	diag_raise();	×
175	}	122,108✔
176
177	#endif /* defined(__cplusplus) */
178
179	#endif /* TARANTOOL_LIB_CORE_TRIGGER_H_INCLUDED */

tarantool / tarantool / 11029368633

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