[babeltrace.git] / src / lib / object.h

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
 * Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 */

#ifndef BABELTRACE_OBJECT_INTERNAL_H
#define BABELTRACE_OBJECT_INTERNAL_H

#include "common/assert.h"
#include <stdbool.h>

struct bt_object;

typedef void (*bt_object_release_func)(struct bt_object *);
typedef void (*bt_object_parent_is_owner_listener_func)(
		struct bt_object *);

static inline
void bt_object_get_ref_no_null_check(const void *obj);

static inline
void bt_object_put_ref_no_null_check(const void *obj);

/*
 * Babeltrace object base.
 *
 * All objects publicly exposed by Babeltrace APIs must contain this
 * object as their first member.
 */
struct bt_object {
	/*
	 * True if this object is shared, that is, it has a reference
	 * count.
	 */
	bool is_shared;

	/*
	 * Current reference count.
	 */
	unsigned long long ref_count;

	/*
	 * Release function called when the object's reference count
	 * falls to zero. For an object with a parent, this function is
	 * bt_object_with_parent_release_func(), which calls
	 * `spec_release_func` below if there's no current parent.
	 */
	bt_object_release_func release_func;

	/*
	 * Specific release function called by
	 * bt_object_with_parent_release_func() or directly by a
	 * parent object.
	 */
	bt_object_release_func spec_release_func;

	/*
	 * Optional callback for an object with a parent, called by
	 * bt_object_with_parent_release_func() to indicate to the
	 * object that its parent is its owner.
	 */
	bt_object_parent_is_owner_listener_func
		parent_is_owner_listener_func;

	/*
	 * Optional parent object.
	 */
	struct bt_object *parent;
};

static inline
unsigned long long bt_object_get_ref_count(const struct bt_object *c_obj)
{
	struct bt_object *obj = (void *) c_obj;

	BT_ASSERT_DBG(obj);
	BT_ASSERT_DBG(obj->is_shared);
	return obj->ref_count;
}

static inline
struct bt_object *bt_object_borrow_parent(const struct bt_object *c_obj)
{
	struct bt_object *obj = (void *) c_obj;

	BT_ASSERT_DBG(obj);
	BT_ASSERT_DBG(obj->is_shared);
	return obj->parent;
}

static inline
struct bt_object *bt_object_get_parent(const struct bt_object *c_obj)
{
	struct bt_object *obj = (void *) c_obj;
	struct bt_object *parent = bt_object_borrow_parent(obj);

	if (parent) {
		bt_object_get_ref_no_null_check(parent);
	}

	return parent;
}

static inline
void bt_object_set_parent(struct bt_object *child, struct bt_object *parent)
{
	BT_ASSERT_DBG(child);
	BT_ASSERT_DBG(child->is_shared);

#ifdef BT_LOGT
	BT_LOGT("Setting object's parent: addr=%p, parent-addr=%p",
		child, parent);
#endif

	/*
	 * It is assumed that a "child" having a parent is publicly
	 * reachable. Therefore, a reference to its parent must be
	 * taken. The reference to the parent will be released once the
	 * object's reference count falls to zero.
	 */
	if (parent) {
		BT_ASSERT_DBG(!child->parent);
		child->parent = parent;
		bt_object_get_ref_no_null_check(parent);
	} else {
		if (child->parent) {
			bt_object_put_ref_no_null_check(child->parent);
		}

		child->parent = NULL;
	}
}

static inline
void bt_object_try_spec_release(struct bt_object *obj)
{
	BT_ASSERT_DBG(obj);
	BT_ASSERT_DBG(obj->is_shared);
	BT_ASSERT_DBG(obj->spec_release_func);

	if (bt_object_get_ref_count(obj) == 0) {
		obj->spec_release_func(obj);
	}
}

static inline
void bt_object_with_parent_release_func(struct bt_object *obj)
{
	if (obj->parent) {
		/*
		 * Keep our own copy of the parent address because `obj`
		 * could be destroyed in
		 * obj->parent_is_owner_listener_func().
		 */
		struct bt_object *parent = obj->parent;

#ifdef BT_LOGT
		BT_LOGT("Releasing parented object: addr=%p, ref-count=%llu, "
			"parent-addr=%p, parent-ref-count=%llu",
			obj, obj->ref_count,
			parent, parent->ref_count);
#endif

		if (obj->parent_is_owner_listener_func) {
			/*
			 * Object has a chance to destroy itself here
			 * under certain conditions and notify its
			 * parent. At this point the parent is
			 * guaranteed to exist because it's not put yet.
			 */
			obj->parent_is_owner_listener_func(obj);
		}

		/* The release function will be invoked by the parent. */
		bt_object_put_ref_no_null_check(parent);
	} else {
		bt_object_try_spec_release(obj);
	}
}

static inline
void bt_object_init(struct bt_object *obj, bool is_shared,
		bt_object_release_func release_func)
{
	BT_ASSERT_DBG(obj);
	BT_ASSERT_DBG(!is_shared || release_func);
	obj->is_shared = is_shared;
	obj->release_func = release_func;
	obj->parent_is_owner_listener_func = NULL;
	obj->spec_release_func = NULL;
	obj->parent = NULL;
	obj->ref_count = 1;
}

static inline
void bt_object_init_shared(struct bt_object *obj,
		bt_object_release_func release_func)
{
	bt_object_init(obj, true, release_func);
}

static inline
void bt_object_init_unique(struct bt_object *obj)
{
	bt_object_init(obj, false, NULL);
}

static inline
void bt_object_init_shared_with_parent(struct bt_object *obj,
		bt_object_release_func spec_release_func)
{
	BT_ASSERT_DBG(obj);
	BT_ASSERT_DBG(spec_release_func);
	bt_object_init_shared(obj, bt_object_with_parent_release_func);
	obj->spec_release_func = spec_release_func;
}

static inline
void bt_object_set_parent_is_owner_listener_func(struct bt_object *obj,
		bt_object_parent_is_owner_listener_func func)
{
	BT_ASSERT_DBG(obj);
	BT_ASSERT_DBG(obj->is_shared);
	BT_ASSERT_DBG(obj->spec_release_func);
	((struct bt_object *) obj)->parent_is_owner_listener_func = func;
}

static inline
void bt_object_inc_ref_count(const struct bt_object *c_obj)
{
	struct bt_object *obj = (void *) c_obj;

	BT_ASSERT_DBG(obj);
	BT_ASSERT_DBG(obj->is_shared);
	obj->ref_count++;
	BT_ASSERT_DBG(obj->ref_count != 0);
}

static inline
void bt_object_get_ref_no_null_check_no_parent_check(const struct bt_object *c_obj)
{
	struct bt_object *obj = (void *) c_obj;

	BT_ASSERT_DBG(obj);
	BT_ASSERT_DBG(obj->is_shared);

#ifdef BT_LOGT
	BT_LOGT("Incrementing object's reference count: %llu -> %llu: "
		"addr=%p, cur-count=%llu, new-count=%llu",
		obj->ref_count, obj->ref_count + 1,
		obj, obj->ref_count, obj->ref_count + 1);
#endif

	bt_object_inc_ref_count(obj);
}

static inline
void bt_object_get_ref_no_null_check(const void *c_obj)
{
	struct bt_object *obj = (void *) c_obj;

	BT_ASSERT_DBG(obj);
	BT_ASSERT_DBG(obj->is_shared);

	if (G_UNLIKELY(obj->parent && bt_object_get_ref_count(obj) == 0)) {
#ifdef BT_LOGT
		BT_LOGT("Incrementing object's parent's reference count: "
			"addr=%p, parent-addr=%p", obj, obj->parent);
#endif

		bt_object_get_ref_no_null_check(obj->parent);
	}

#ifdef BT_LOGT
	BT_LOGT("Incrementing object's reference count: %llu -> %llu: "
		"addr=%p, cur-count=%llu, new-count=%llu",
		obj->ref_count, obj->ref_count + 1,
		obj, obj->ref_count, obj->ref_count + 1);
#endif

	bt_object_inc_ref_count(obj);
}

static inline
void bt_object_put_ref_no_null_check(const void *c_obj)
{
	struct bt_object *obj = (void *) c_obj;

	BT_ASSERT_DBG(obj);
	BT_ASSERT_DBG(obj->is_shared);
	BT_ASSERT_DBG(obj->ref_count > 0);

#ifdef BT_LOGT
	BT_LOGT("Decrementing object's reference count: %llu -> %llu: "
		"addr=%p, cur-count=%llu, new-count=%llu",
		obj->ref_count, obj->ref_count - 1,
		obj, obj->ref_count, obj->ref_count - 1);
#endif

	obj->ref_count--;

	if (obj->ref_count == 0) {
		BT_ASSERT_DBG(obj->release_func);
		obj->release_func(obj);
	}
}

static inline
void bt_object_get_ref(const void *ptr)
{
	struct bt_object *obj = (void *) ptr;

	if (G_UNLIKELY(!obj)) {
		return;
	}

	BT_ASSERT_DBG(obj->is_shared);
	bt_object_get_ref_no_null_check(obj);
}

static inline
void bt_object_put_ref(const void *ptr)
{
	struct bt_object *obj = (void *) ptr;

	if (G_UNLIKELY(!obj)) {
		return;
	}

	BT_ASSERT_DBG(obj->is_shared);
	BT_ASSERT_DBG(bt_object_get_ref_count(obj) > 0);
	bt_object_put_ref_no_null_check(obj);
}

#define BT_OBJECT_PUT_REF_AND_RESET(_var)	\
	do {					\
		bt_object_put_ref(_var);	\
		(_var) = NULL;			\
	} while (0)

#define BT_OBJECT_MOVE_REF(_var_dst, _var_src)	\
	do {					\
		bt_object_put_ref(_var_dst);	\
		(_var_dst) = (_var_src);	\
		(_var_src) = NULL;		\
	} while (0)

#endif /* BABELTRACE_OBJECT_INTERNAL_H */
Commit	Line	Data
	1	/*
	2	* SPDX-License-Identifier: MIT
	3	*
	4	* Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
	5	* Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	6	*/
	7
	8	#ifndef BABELTRACE_OBJECT_INTERNAL_H
	9	#define BABELTRACE_OBJECT_INTERNAL_H
	10
	11	#include "common/assert.h"
	12	#include <stdbool.h>
	13
	14	struct bt_object;
	15
	16	typedef void (bt_object_release_func)(struct bt_object );
	17	typedef void (*bt_object_parent_is_owner_listener_func)(
	18	struct bt_object *);
	19
	20	static inline
	21	void bt_object_get_ref_no_null_check(const void *obj);
	22
	23	static inline
	24	void bt_object_put_ref_no_null_check(const void *obj);
	25
	26	/*
	27	* Babeltrace object base.
	28	*
	29	* All objects publicly exposed by Babeltrace APIs must contain this
	30	* object as their first member.
	31	*/
	32	struct bt_object {
	33	/*
	34	* True if this object is shared, that is, it has a reference
	35	* count.
	36	*/
	37	bool is_shared;
	38
	39	/*
	40	* Current reference count.
	41	*/
	42	unsigned long long ref_count;
	43
	44	/*
	45	* Release function called when the object's reference count
	46	* falls to zero. For an object with a parent, this function is
	47	* bt_object_with_parent_release_func(), which calls
	48	* `spec_release_func` below if there's no current parent.
	49	*/
	50	bt_object_release_func release_func;
	51
	52	/*
	53	* Specific release function called by
	54	* bt_object_with_parent_release_func() or directly by a
	55	* parent object.
	56	*/
	57	bt_object_release_func spec_release_func;
	58
	59	/*
	60	* Optional callback for an object with a parent, called by
	61	* bt_object_with_parent_release_func() to indicate to the
	62	* object that its parent is its owner.
	63	*/
	64	bt_object_parent_is_owner_listener_func
	65	parent_is_owner_listener_func;
	66
	67	/*
	68	* Optional parent object.
	69	*/
	70	struct bt_object *parent;
	71	};
	72
	73	static inline
	74	unsigned long long bt_object_get_ref_count(const struct bt_object *c_obj)
	75	{
	76	struct bt_object obj = (void ) c_obj;
	77
	78	BT_ASSERT_DBG(obj);
	79	BT_ASSERT_DBG(obj->is_shared);
	80	return obj->ref_count;
	81	}
	82
	83	static inline
	84	struct bt_object bt_object_borrow_parent(const struct bt_object c_obj)
	85	{
	86	struct bt_object obj = (void ) c_obj;
	87
	88	BT_ASSERT_DBG(obj);
	89	BT_ASSERT_DBG(obj->is_shared);
	90	return obj->parent;
	91	}
	92
	93	static inline
	94	struct bt_object bt_object_get_parent(const struct bt_object c_obj)
	95	{
	96	struct bt_object obj = (void ) c_obj;
	97	struct bt_object *parent = bt_object_borrow_parent(obj);
	98
	99	if (parent) {
	100	bt_object_get_ref_no_null_check(parent);
	101	}
	102
	103	return parent;
	104	}
	105
	106	static inline
	107	void bt_object_set_parent(struct bt_object child, struct bt_object parent)
	108	{
	109	BT_ASSERT_DBG(child);
	110	BT_ASSERT_DBG(child->is_shared);
	111
	112	#ifdef BT_LOGT
	113	BT_LOGT("Setting object's parent: addr=%p, parent-addr=%p",
	114	child, parent);
	115	#endif
	116
	117	/*
	118	* It is assumed that a "child" having a parent is publicly
	119	* reachable. Therefore, a reference to its parent must be
	120	* taken. The reference to the parent will be released once the
	121	* object's reference count falls to zero.
	122	*/
	123	if (parent) {
	124	BT_ASSERT_DBG(!child->parent);
	125	child->parent = parent;
	126	bt_object_get_ref_no_null_check(parent);
	127	} else {
	128	if (child->parent) {
	129	bt_object_put_ref_no_null_check(child->parent);
	130	}
	131
	132	child->parent = NULL;
	133	}
	134	}
	135
	136	static inline
	137	void bt_object_try_spec_release(struct bt_object *obj)
	138	{
	139	BT_ASSERT_DBG(obj);
	140	BT_ASSERT_DBG(obj->is_shared);
	141	BT_ASSERT_DBG(obj->spec_release_func);
	142
	143	if (bt_object_get_ref_count(obj) == 0) {
	144	obj->spec_release_func(obj);
	145	}
	146	}
	147
	148	static inline
	149	void bt_object_with_parent_release_func(struct bt_object *obj)
	150	{
	151	if (obj->parent) {
	152	/*
	153	* Keep our own copy of the parent address because `obj`
	154	* could be destroyed in
	155	* obj->parent_is_owner_listener_func().
	156	*/
	157	struct bt_object *parent = obj->parent;
	158
	159	#ifdef BT_LOGT
	160	BT_LOGT("Releasing parented object: addr=%p, ref-count=%llu, "
	161	"parent-addr=%p, parent-ref-count=%llu",
	162	obj, obj->ref_count,
	163	parent, parent->ref_count);
	164	#endif
	165
	166	if (obj->parent_is_owner_listener_func) {
	167	/*
	168	* Object has a chance to destroy itself here
	169	* under certain conditions and notify its
	170	* parent. At this point the parent is
	171	* guaranteed to exist because it's not put yet.
	172	*/
	173	obj->parent_is_owner_listener_func(obj);
	174	}
	175
	176	/* The release function will be invoked by the parent. */
	177	bt_object_put_ref_no_null_check(parent);
	178	} else {
	179	bt_object_try_spec_release(obj);
	180	}
	181	}
	182
	183	static inline
	184	void bt_object_init(struct bt_object *obj, bool is_shared,
	185	bt_object_release_func release_func)
	186	{
	187	BT_ASSERT_DBG(obj);
	188	BT_ASSERT_DBG(!is_shared \|\| release_func);
	189	obj->is_shared = is_shared;
	190	obj->release_func = release_func;
	191	obj->parent_is_owner_listener_func = NULL;
	192	obj->spec_release_func = NULL;
	193	obj->parent = NULL;
	194	obj->ref_count = 1;
	195	}
	196
	197	static inline
	198	void bt_object_init_shared(struct bt_object *obj,
	199	bt_object_release_func release_func)
	200	{
	201	bt_object_init(obj, true, release_func);
	202	}
	203
	204	static inline
	205	void bt_object_init_unique(struct bt_object *obj)
	206	{
	207	bt_object_init(obj, false, NULL);
	208	}
	209
	210	static inline
	211	void bt_object_init_shared_with_parent(struct bt_object *obj,
	212	bt_object_release_func spec_release_func)
	213	{
	214	BT_ASSERT_DBG(obj);
	215	BT_ASSERT_DBG(spec_release_func);
	216	bt_object_init_shared(obj, bt_object_with_parent_release_func);
	217	obj->spec_release_func = spec_release_func;
	218	}
	219
	220	static inline
	221	void bt_object_set_parent_is_owner_listener_func(struct bt_object *obj,
	222	bt_object_parent_is_owner_listener_func func)
	223	{
	224	BT_ASSERT_DBG(obj);
	225	BT_ASSERT_DBG(obj->is_shared);
	226	BT_ASSERT_DBG(obj->spec_release_func);
	227	((struct bt_object *) obj)->parent_is_owner_listener_func = func;
	228	}
	229
	230	static inline
	231	void bt_object_inc_ref_count(const struct bt_object *c_obj)
	232	{
	233	struct bt_object obj = (void ) c_obj;
	234
	235	BT_ASSERT_DBG(obj);
	236	BT_ASSERT_DBG(obj->is_shared);
	237	obj->ref_count++;
	238	BT_ASSERT_DBG(obj->ref_count != 0);
	239	}
	240
	241	static inline
	242	void bt_object_get_ref_no_null_check_no_parent_check(const struct bt_object *c_obj)
	243	{
	244	struct bt_object obj = (void ) c_obj;
	245
	246	BT_ASSERT_DBG(obj);
	247	BT_ASSERT_DBG(obj->is_shared);
	248
	249	#ifdef BT_LOGT
	250	BT_LOGT("Incrementing object's reference count: %llu -> %llu: "
	251	"addr=%p, cur-count=%llu, new-count=%llu",
	252	obj->ref_count, obj->ref_count + 1,
	253	obj, obj->ref_count, obj->ref_count + 1);
	254	#endif
	255
	256	bt_object_inc_ref_count(obj);
	257	}
	258
	259	static inline
	260	void bt_object_get_ref_no_null_check(const void *c_obj)
	261	{
	262	struct bt_object obj = (void ) c_obj;
	263
	264	BT_ASSERT_DBG(obj);
	265	BT_ASSERT_DBG(obj->is_shared);
	266
	267	if (G_UNLIKELY(obj->parent && bt_object_get_ref_count(obj) == 0)) {
	268	#ifdef BT_LOGT
	269	BT_LOGT("Incrementing object's parent's reference count: "
	270	"addr=%p, parent-addr=%p", obj, obj->parent);
	271	#endif
	272
	273	bt_object_get_ref_no_null_check(obj->parent);
	274	}
	275
	276	#ifdef BT_LOGT
	277	BT_LOGT("Incrementing object's reference count: %llu -> %llu: "
	278	"addr=%p, cur-count=%llu, new-count=%llu",
	279	obj->ref_count, obj->ref_count + 1,
	280	obj, obj->ref_count, obj->ref_count + 1);
	281	#endif
	282
	283	bt_object_inc_ref_count(obj);
	284	}
	285
	286	static inline
	287	void bt_object_put_ref_no_null_check(const void *c_obj)
	288	{
	289	struct bt_object obj = (void ) c_obj;
	290
	291	BT_ASSERT_DBG(obj);
	292	BT_ASSERT_DBG(obj->is_shared);
	293	BT_ASSERT_DBG(obj->ref_count > 0);
	294
	295	#ifdef BT_LOGT
	296	BT_LOGT("Decrementing object's reference count: %llu -> %llu: "
	297	"addr=%p, cur-count=%llu, new-count=%llu",
	298	obj->ref_count, obj->ref_count - 1,
	299	obj, obj->ref_count, obj->ref_count - 1);
	300	#endif
	301
	302	obj->ref_count--;
	303
	304	if (obj->ref_count == 0) {
	305	BT_ASSERT_DBG(obj->release_func);
	306	obj->release_func(obj);
	307	}
	308	}
	309
	310	static inline
	311	void bt_object_get_ref(const void *ptr)
	312	{
	313	struct bt_object obj = (void ) ptr;
	314
	315	if (G_UNLIKELY(!obj)) {
	316	return;
	317	}
	318
	319	BT_ASSERT_DBG(obj->is_shared);
	320	bt_object_get_ref_no_null_check(obj);
	321	}
	322
	323	static inline
	324	void bt_object_put_ref(const void *ptr)
	325	{
	326	struct bt_object obj = (void ) ptr;
	327
	328	if (G_UNLIKELY(!obj)) {
	329	return;
	330	}
	331
	332	BT_ASSERT_DBG(obj->is_shared);
	333	BT_ASSERT_DBG(bt_object_get_ref_count(obj) > 0);
	334	bt_object_put_ref_no_null_check(obj);
	335	}
	336
	337	#define BT_OBJECT_PUT_REF_AND_RESET(_var) \
	338	do { \
	339	bt_object_put_ref(_var); \
	340	(_var) = NULL; \
	341	} while (0)
	342
	343	#define BT_OBJECT_MOVE_REF(_var_dst, _var_src) \
	344	do { \
	345	bt_object_put_ref(_var_dst); \
	346	(_var_dst) = (_var_src); \
	347	(_var_src) = NULL; \
	348	} while (0)
	349
	350	#endif /* BABELTRACE_OBJECT_INTERNAL_H */