mirrors
/
weston
mirror of https://gitlab.freedesktop.org/wayland/weston.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
weston/shared/weston-assert.h

150 lines
5.0 KiB
C
Raw Normal View History

shared: add weston-assert Add yet another flavor of assertion macros. Unlike libc assert.h assert(), these cannot be easily disabled by the build. They also print both the implied expression and the compared values. Unlike ZUC macros, there is much less framework code and it can handle also floating-point types. The function custom_assert_fail_ can be redefined, meaning that different compilation units can do different things on failure. Also the 'compositor' parameter was added to the new macros because we plan to use these asserts in our log infrastructure, and we want to print the "failure" messages in the right log scopes. Having the compositor already in the macros will avoid double work. Another future possibility is to write specific asserts for the test suite. So we would be able to write a test suite failure function that just print what "failed" without aborting. There is also limited support for custom types. These are actually pretty similar to libinput's litest macros. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com> Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2022-06-02 12:10:45 +03:00
/*
* Copyright 2022 Collabora, Ltd.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
shared: include missing header to weston-assert We forgot to include stdbool to weston-assert.h, but this was not causing issues because callers of weston_assert_true() themselves include stdbool. Add stdbool to weston-assert, as this is the right thing to do. Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2024-01-11 01:33:04 +03:00
#include <stdbool.h>
shared: add weston_assert_bit_is_set() Will be used in the next patch. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
2024-02-16 15:55:39 +03:00
#include <inttypes.h>
shared: add weston-assert Add yet another flavor of assertion macros. Unlike libc assert.h assert(), these cannot be easily disabled by the build. They also print both the implied expression and the compared values. Unlike ZUC macros, there is much less framework code and it can handle also floating-point types. The function custom_assert_fail_ can be redefined, meaning that different compilation units can do different things on failure. Also the 'compositor' parameter was added to the new macros because we plan to use these asserts in our log infrastructure, and we want to print the "failure" messages in the right log scopes. Having the compositor already in the macros will avoid double work. Another future possibility is to write specific asserts for the test suite. So we would be able to write a test suite failure function that just print what "failed" without aborting. There is also limited support for custom types. These are actually pretty similar to libinput's litest macros. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com> Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2022-06-02 12:10:45 +03:00
struct weston_compositor;
__attribute__((noreturn, format(printf, 2, 3)))
static inline void
weston_assert_fail_(const struct weston_compositor *compositor, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
abort();
}
#ifndef custom_assert_fail_
#define custom_assert_fail_ weston_assert_fail_
#endif
#define weston_assert_(compositor, a, b, val_type, val_fmt, cmp) \
({ \
struct weston_compositor *ec = compositor; \
val_type a_ = (a); \
val_type b_ = (b); \
bool cond = a_ cmp b_; \
if (!cond) \
custom_assert_fail_(ec, "%s:%u: Assertion %s %s %s (" val_fmt " %s " val_fmt ") failed!\n", \
__FILE__, __LINE__, #a, #cmp, #b, a_, #cmp, b_); \
cond; \
})
#define weston_assert_fn_(compositor, fn, a, b, val_type, val_fmt, cmp) \
({ \
struct weston_compositor *ec = compositor; \
val_type a_ = (a); \
val_type b_ = (b); \
bool cond = fn(a_, b_) cmp 0; \
if (!cond) \
custom_assert_fail_(ec, "%s:%u: Assertion %s %s %s (" val_fmt " %s " val_fmt ") failed!\n", \
__FILE__, __LINE__, #a, #cmp, #b, a_, #cmp, b_); \
cond; \
})
libweston: add unique id generator This is preparation for the CM&HDR protocol implementation. It requires us to give a unique id to each color-profile, so let's do that. In this commit we introduce a generic id generator to libweston, and its first user: the color-profile. Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2024-01-11 00:49:17 +03:00
#define weston_assert_not_reached(compositor, reason) \
do { \
struct weston_compositor *ec = compositor; \
custom_assert_fail_(ec, "%s:%u: Assertion failed! This should not be reached: %s\n", \
__FILE__, __LINE__, reason); \
} while (0)
shared: add weston-assert Add yet another flavor of assertion macros. Unlike libc assert.h assert(), these cannot be easily disabled by the build. They also print both the implied expression and the compared values. Unlike ZUC macros, there is much less framework code and it can handle also floating-point types. The function custom_assert_fail_ can be redefined, meaning that different compilation units can do different things on failure. Also the 'compositor' parameter was added to the new macros because we plan to use these asserts in our log infrastructure, and we want to print the "failure" messages in the right log scopes. Having the compositor already in the macros will avoid double work. Another future possibility is to write specific asserts for the test suite. So we would be able to write a test suite failure function that just print what "failed" without aborting. There is also limited support for custom types. These are actually pretty similar to libinput's litest macros. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com> Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2022-06-02 12:10:45 +03:00
#define weston_assert_true(compositor, a) \
weston_assert_(compositor, a, true, bool, "%d", ==)
shared: add weston_assert_false() Complement to weston_assert_true(), to avoid having to use !. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
2024-05-02 15:04:46 +03:00
#define weston_assert_false(compositor, a) \
weston_assert_(compositor, a, false, bool, "%d", ==)
shared: add weston-assert Add yet another flavor of assertion macros. Unlike libc assert.h assert(), these cannot be easily disabled by the build. They also print both the implied expression and the compared values. Unlike ZUC macros, there is much less framework code and it can handle also floating-point types. The function custom_assert_fail_ can be redefined, meaning that different compilation units can do different things on failure. Also the 'compositor' parameter was added to the new macros because we plan to use these asserts in our log infrastructure, and we want to print the "failure" messages in the right log scopes. Having the compositor already in the macros will avoid double work. Another future possibility is to write specific asserts for the test suite. So we would be able to write a test suite failure function that just print what "failed" without aborting. There is also limited support for custom types. These are actually pretty similar to libinput's litest macros. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com> Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2022-06-02 12:10:45 +03:00
#define weston_assert_ptr(compositor, a) \
weston_assert_(compositor, a, NULL, const void *, "%p", !=)
#define weston_assert_ptr_is_null(compositor, a) \
weston_assert_(compositor, a, NULL, const void *, "%p", ==)
#define weston_assert_ptr_eq(compositor, a, b) \
weston_assert_(compositor, a, b, const void *, "%p", ==)
#define weston_assert_double_eq(compositor, a, b) \
weston_assert_(compositor, a, b, double, "%.10g", ==)
color-lcms: add translate_curve_element_LUT() Currently in translate_curve_element() we always translate the curve into a LUT. But in the future we'll be able to translate the curves to parametric ones. So move the current code to a new function translate_curve_element_LUT(), so that in translate_curve_element() we are able to call one of the two functions (_LUT() or _parametric()). No behavior changes, just preparation for the upcoming patches. Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2024-03-07 23:32:19 +03:00
#define weston_assert_uint32_eq(compositor, a, b) \
weston_assert_(compositor, a, b, uint32_t, "%u", ==)
libweston: add unique id generator This is preparation for the CM&HDR protocol implementation. It requires us to give a unique id to each color-profile, so let's do that. In this commit we introduce a generic id generator to libweston, and its first user: the color-profile. Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2024-01-11 00:49:17 +03:00
#define weston_assert_uint32_neq(compositor, a, b) \
weston_assert_(compositor, a, b, uint32_t, "%u", !=)
color: add support to the color-management protocol In this MR we add support to the majority of the interfaces from the color-management protocol. That means that we are able to advertise output's images descriptions to clients, preferred surface images descriptions, and so on. We also support clients that wants to create ICC-based images descriptions and set such descriptions for surfaces. We still don't support the interface to allow clients to create image descriptions from parameters, but that should be addressed in the near future. Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2024-01-26 18:15:51 +03:00
#define weston_assert_uint32_gt(compositor, a, b) \
weston_assert_(compositor, a, b, uint32_t, "%u", >)
color-noop: avoid assert hit in cmnoop_destroy() When we are destroying the color manager, the components referencing color profiles should have already been destroyed. We have an assert in cmnoop_destroy() to make sure that the stock profile has refcount equal to 1. But we currently have an issue in Weston. While shutting down with client surfaces alive, we may leak them. So we try to destroy the color manager with surfaces still alive, and they may be referencing color profiles. We already have a workaround for this in our LittleCMS color plugin, but we've missed that in color-noop. This fixes that, so now we don't hit the assert anymore. As we are already dealing with asserts in color-noop, I took the liberty to replace the last usage of assert with our own wrapper in this file. Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2024-02-21 19:08:42 +03:00
#define weston_assert_uint32_gt_or_eq(compositor, a, b) \
weston_assert_(compositor, a, b, uint32_t, "%u", >=)
libweston: add unique id generator This is preparation for the CM&HDR protocol implementation. It requires us to give a unique id to each color-profile, so let's do that. In this commit we introduce a generic id generator to libweston, and its first user: the color-profile. Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2024-01-11 00:49:17 +03:00
#define weston_assert_uint32_lt(compositor, a, b) \
weston_assert_(compositor, a, b, uint32_t, "%u", <)
color-lcms: changes to the parameters of translate_curve_element() Not a behavior change, but this allow us to decide what function pointer to use within this function (instead of forcing callers to decide that). In the following commits this will be helpful. We'll add more curves besides 3x1D LUT's and, depending on the curve, the function pointer signature may differ. Also, we now pass the xform directly to the function, and it can select the curves depending if it is being called for a pre or a post curve. Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2023-11-15 18:56:49 +03:00
#define weston_assert_uint64_eq(compositor, a, b) \
weston_assert_(compositor, a, b, uint64_t, "%" PRIx64, ==)
shared: add weston-assert Add yet another flavor of assertion macros. Unlike libc assert.h assert(), these cannot be easily disabled by the build. They also print both the implied expression and the compared values. Unlike ZUC macros, there is much less framework code and it can handle also floating-point types. The function custom_assert_fail_ can be redefined, meaning that different compilation units can do different things on failure. Also the 'compositor' parameter was added to the new macros because we plan to use these asserts in our log infrastructure, and we want to print the "failure" messages in the right log scopes. Having the compositor already in the macros will avoid double work. Another future possibility is to write specific asserts for the test suite. So we would be able to write a test suite failure function that just print what "failed" without aborting. There is also limited support for custom types. These are actually pretty similar to libinput's litest macros. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com> Signed-off-by: Leandro Ribeiro <leandro.ribeiro@collabora.com>
2022-06-02 12:10:45 +03:00
#define weston_assert_str_eq(compositor, a, b) \
weston_assert_fn_(compositor, strcmp, a, b, const char *, "%s", ==)
shared: add weston_assert_bit_is_set() Will be used in the next patch. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
2024-02-16 15:55:39 +03:00
#define weston_assert_bit_is_set(compositor, value, bit) \
({ \
struct weston_compositor *ec = compositor; \
uint64_t v = (value); \
uint8_t b = (bit); \
bool cond = (v >> b) & 1; \
if (!cond) \
custom_assert_fail_(ec, "%s:%u: Assertion failed! Bit %s (%u) of %s (0x%" PRIx64 ") is not set.\n", \
__FILE__, __LINE__, #bit, b, #value, v); \
cond; \
})
shared: add weston_assert_legal_bits() Helper to assert that a value does not have any bit set outside of the mask. To be used with "all bits mask" of enum types that enumerate bits. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
2024-05-02 14:40:35 +03:00
#define weston_assert_legal_bits(compositor, value, mask) \
({ \
struct weston_compositor *ec = compositor; \
uint64_t v_ = (value); \
uint64_t m_ = (mask); \
uint64_t ill = v_ & ~m_; \
bool cond = ill == 0; \
if (!cond) \
custom_assert_fail_(ec, "%s:%u: Assertion failed! " \
"Value %s (0x%" PRIx64 ") contains illegal bits 0x%" PRIx64 ". " \
"Legal mask is %s (0x%" PRIx64 ").\n", \
__FILE__, __LINE__, #value, v_, ill, #mask, m_); \
cond; \
})