summaryrefslogtreecommitdiff
path: root/src/qcam/main_window.h
diff options
context:
space:
mode:
authorLaurent Pinchart <laurent.pinchart@ideasonboard.com>2021-07-02 01:30:41 +0300
committerLaurent Pinchart <laurent.pinchart@ideasonboard.com>2021-07-11 17:42:02 +0300
commitda9b6bb196e0165342a414657edfc5aaf165baa5 (patch)
tree82dddf1faf7e571f1a7781a96f70b0d92b60115b /src/qcam/main_window.h
parent1f7f7a72ed47a4a9cbfcda9dc26f490d5ef7b1af (diff)
base: thread: Fix recursive calls to dispatchMessages()
There are use cases for calling the dispatchMessages() function recursively, from within a message handler. This can be used, for instance, to force delivery of messages posted to a thread concurrently to stopping the thread. This currently causes access, in the outer dispatchMessages() call, to iterators that have been invalidated by erasing list elements in the recursive call, leading to undefined behaviour (most likely double-free or other crashes). Fix it by only erasing messages from the list at the end of the outer call, identified using a recursion counter. Bug: https://bugs.libcamera.org/show_bug.cgi?id=26 Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Jacopo Mondi <jacopo@jmondi.org> Tested-by: David Plowman <david.plowman@raspberrypi.com> Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
Diffstat (limited to 'src/qcam/main_window.h')
0 files changed, 0 insertions, 0 deletions
a id='n144' href='#n144'>144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2020, Google Inc.
 *
 * generated_serializer_test.cpp - Test generated serializer
 */

#include <algorithm>
#include <tuple>
#include <vector>

#include "test.h"

#include "test_ipa_interface.h"
#include "test_ipa_serializer.h"

using namespace std;
using namespace libcamera;

class IPAGeneratedSerializerTest : public Test
{
protected:
	int init() override
	{
		return TestPass;
	}

	int run() override
	{

#define TEST_FIELD_EQUALITY(struct1, struct2, field)		\
if (struct1.field != struct2.field) {				\
	cerr << #field << " field incorrect: expected \""	\
	     << t.field << "\", got \"" << u.field << "\"" << endl;\
	return TestFail;					\
}

#define TEST_SCOPED_ENUM_EQUALITY(struct1, struct2, field)	\
if (struct1.field != struct2.field) {				\
	cerr << #field << " field incorrect" << endl;		\
	return TestFail;					\
}


		ipa::test::TestStruct t, u;

		t.m = {
			{ "a", "z" },
			{ "b", "z" },
			{ "c", "z" },
			{ "d", "z" },
			{ "e", "z" },
		};

		t.a = { "a", "b", "c", "d", "e" };

		t.s1 = "hello world";
		t.s2 = "goodbye";
		t.s3 = "lorem ipsum";
		t.i  = 58527;
		t.c = ipa::test::IPAOperationInit;
		t.e = ipa::test::ErrorFlags::Error1;

		Flags<ipa::test::ErrorFlags> flags;
		flags |= ipa::test::ErrorFlags::Error1;
		flags |= ipa::test::ErrorFlags::Error2;
		t.f = flags;

		std::vector<uint8_t> serialized;

		std::tie(serialized, ignore) =
			IPADataSerializer<ipa::test::TestStruct>::serialize(t);

		u = IPADataSerializer<ipa::test::TestStruct>::deserialize(serialized);

		if (!equals(t.m, u.m))
			return TestFail;

		if (!equals(t.a, u.a))
			return TestFail;

		TEST_FIELD_EQUALITY(t, u, s1);
		TEST_FIELD_EQUALITY(t, u, s2);
		TEST_FIELD_EQUALITY(t, u, s3);
		TEST_FIELD_EQUALITY(t, u, i);
		TEST_FIELD_EQUALITY(t, u, c);

		TEST_SCOPED_ENUM_EQUALITY(t, u, e);
		TEST_SCOPED_ENUM_EQUALITY(t, u, f);

		/* Test vector of generated structs */
		std::vector<ipa::test::TestStruct> v = { t, u };
		std::vector<ipa::test::TestStruct> w;

		std::tie(serialized, ignore) =
			IPADataSerializer<vector<ipa::test::TestStruct>>::serialize(v);

		w = IPADataSerializer<vector<ipa::test::TestStruct>>::deserialize(serialized);

		if (!equals(v[0].m, w[0].m) ||
		    !equals(v[1].m, w[1].m))
			return TestFail;

		if (!equals(v[0].a, w[0].a) ||
		    !equals(v[1].a, w[1].a))
			return TestFail;

		TEST_FIELD_EQUALITY(v[0], w[0], s1);
		TEST_FIELD_EQUALITY(v[0], w[0], s2);
		TEST_FIELD_EQUALITY(v[0], w[0], s3);
		TEST_FIELD_EQUALITY(v[0], w[0], i);
		TEST_FIELD_EQUALITY(v[0], w[0], c);

		TEST_SCOPED_ENUM_EQUALITY(v[0], w[0], e);
		TEST_SCOPED_ENUM_EQUALITY(v[0], w[0], f);

		TEST_FIELD_EQUALITY(v[1], w[1], s1);
		TEST_FIELD_EQUALITY(v[1], w[1], s2);
		TEST_FIELD_EQUALITY(v[1], w[1], s3);
		TEST_FIELD_EQUALITY(v[1], w[1], i);
		TEST_FIELD_EQUALITY(v[1], w[1], c);

		TEST_SCOPED_ENUM_EQUALITY(v[1], w[1], e);
		TEST_SCOPED_ENUM_EQUALITY(v[1], w[1], f);

		return TestPass;
	}

private:
	bool equals(const map<string, string> &lhs, const map<string, string> &rhs)
	{
		bool eq = lhs.size() == rhs.size() &&
			  equal(lhs.begin(), lhs.end(), rhs.begin(),
				[](auto &a, auto &b) { return a.first == b.first &&
							      a.second == b.second; });

		if (eq)
			return true;

		cerr << "lhs:" << endl;
		for (const auto &pair : lhs)
			cerr << "- " << pair.first << ": "
			     << pair.second << endl;

		cerr << "rhs:" << endl;
		for (const auto &pair : rhs)
			cerr << "- " << pair.first << ": "
			     << pair.second << endl;

		return false;
	}

	bool equals(const vector<string> &lhs, const vector<string> &rhs)
	{
		bool eq = lhs.size() == rhs.size();

		if (!eq) {
			cerr << "sizes not equal" << endl;
			return false;
		}

		for (unsigned int i = 0; i < lhs.size(); i++)
			if (lhs[i] != rhs[i])
				eq = false;

		if (eq)
			return true;

		cerr << "lhs:" << endl;
		for (const auto &str : lhs)
			cerr << "- " << str << endl;

		cerr << "rhs:" << endl;
		for (const auto &str : rhs)
			cerr << "- " << str << endl;

		return false;
	}
};

TEST_REGISTER(IPAGeneratedSerializerTest)