From 4afd3348c7506dd1d36305b7bcb9feb8952b9d6b Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Fri, 27 Nov 2015 19:13:45 +0100 Subject: tree-wide: expose "p"-suffix unref calls in public APIs to make gcc cleanup easy GLIB has recently started to officially support the gcc cleanup attribute in its public API, hence let's do the same for our APIs. With this patch we'll define an xyz_unrefp() call for each public xyz_unref() call, to make it easy to use inside a __attribute__((cleanup())) expression. Then, all code is ported over to make use of this. The new calls are also documented in the man pages, with examples how to use them (well, I only added docs where the _unref() call itself already had docs, and the examples, only cover sd_bus_unrefp() and sd_event_unrefp()). This also renames sd_lldp_free() to sd_lldp_unref(), since that's how we tend to call our destructors these days. Note that this defines no public macro that wraps gcc's attribute and makes it easier to use. While I think it's our duty in the library to make our stuff easy to use, I figure it's not our duty to make gcc's own features easy to use on its own. Most likely, client code which wants to make use of this should define its own: #define _cleanup_(function) __attribute__((cleanup(function))) Or similar, to make the gcc feature easier to use. Making this logic public has the benefit that we can remove three header files whose only purpose was to define these functions internally. See #2008. --- man/sd_bus_creds_new_from_pid.xml | 21 +++++++++++++++++ man/sd_bus_new.xml | 48 ++++++++++++++++++++++++++++++++------- man/sd_event_new.xml | 31 +++++++++++++++++++++++-- man/sd_event_source_unref.xml | 21 +++++++++++++++-- man/sd_login_monitor_new.xml | 31 +++++++++++++++++++++++++ 5 files changed, 140 insertions(+), 12 deletions(-) (limited to 'man') diff --git a/man/sd_bus_creds_new_from_pid.xml b/man/sd_bus_creds_new_from_pid.xml index 84dd509744..082f7b67db 100644 --- a/man/sd_bus_creds_new_from_pid.xml +++ b/man/sd_bus_creds_new_from_pid.xml @@ -48,6 +48,7 @@ sd_bus_creds_get_augmented_mask sd_bus_creds_ref sd_bus_creds_unref + sd_bus_creds_unrefp Retrieve credentials object for the specified PID @@ -82,6 +83,11 @@ sd_bus_creds *sd_bus_creds_unref sd_bus_creds *c + + + void sd_bus_creds_unrefp + sd_bus_creds **c + @@ -235,6 +241,21 @@ sd_bus_creds_unref() destroys a reference to c. + + sd_bus_creds_unrefp() is similar to + sd_bus_creds_unref() but takes a pointer to a + pointer to an sd_bus_creds object. This call is useful in + conjunction with GCC's and LLVM's Clean-up + Variable Attribute. Note that this function is defined as + inline function. + + sd_bus_creds_ref(), + sd_bus_creds_unref() and + sd_bus_creds_unrefp() execute no operation if + the passed in bus credentials object is + NULL. + diff --git a/man/sd_bus_new.xml b/man/sd_bus_new.xml index e1cab6e567..d281b5dd44 100644 --- a/man/sd_bus_new.xml +++ b/man/sd_bus_new.xml @@ -46,6 +46,7 @@ sd_bus_new sd_bus_ref sd_bus_unref + sd_bus_unrefp Create a new bus object and create or destroy references to it @@ -68,6 +69,11 @@ sd_bus *sd_bus_unref sd_bus *bus + + + void sd_bus_unrefp + sd_bus **bus + @@ -93,14 +99,40 @@ only allocate a bus object but also start the connection to a well-known bus in a single function invocation. - sd_bus_ref() creates a new reference to - bus. + sd_bus_ref() increases the reference + counter of bus by one. - sd_bus_unref() destroys a reference to - bus. Once the reference count has dropped - to zero, bus cannot be used anymore, so - further calls to sd_bus_ref() or + sd_bus_unref() decreases the reference + counter of bus by one. Once the reference + count has dropped to zero, bus is destroyed + and cannot be used anymore, so further calls to + sd_bus_ref() or sd_bus_unref() are illegal. + + sd_bus_unrefp() is similar to + sd_bus_unref() but takes a pointer to a + pointer to an sd_bus object. This call is useful in + conjunction with GCC's and LLVM's Clean-up + Variable Attribute. Note that this function is defined as + inline function. Use a declaration like the following, in order to + allocate a bus object that is freed automatically as the code + block is left: + + { + __attribute__((cleanup(sd_bus_unrefp)) sd_bus *bus = NULL; + int r; + … + r = sd_bus_default(&bus); + if (r < 0) + fprintf(stderr, "Failed to allocate bus: %s\n", strerror(-r)); + … +} + + sd_bus_ref(), + sd_bus_unref() and + sd_bus_unrefp() execute no operation if the + passed in bus object is NULL. @@ -110,10 +142,10 @@ positive integer. On failure, it returns a negative errno-style error code. - sd_bus_ref always returns the argument. + sd_bus_ref() always returns the argument. - sd_bus_unref always returns + sd_bus_unref() always returns NULL. diff --git a/man/sd_event_new.xml b/man/sd_event_new.xml index 3356faa899..2c23b00a8c 100644 --- a/man/sd_event_new.xml +++ b/man/sd_event_new.xml @@ -47,6 +47,7 @@ sd_event_default sd_event_ref sd_event_unref + sd_event_unrefp sd_event_get_tid sd_event @@ -79,6 +80,11 @@ sd_event *event + + void sd_event_unrefp + sd_event **event + + int sd_event_get_tid sd_event *event @@ -139,8 +145,29 @@ all remaining event sources of the event loop also need to be freed as each keeps a reference to it. - Both sd_event_ref() and - sd_event_unref() execute no operation if the + sd_event_unrefp() is similar to + sd_event_unref() but takes a pointer to a + pointer to an sd_event object. This call is useful in + conjunction with GCC's and LLVM's Clean-up + Variable Attribute. Note that this function is defined as + inline function. Use a declaration like the following, + in order to allocate an event loop object that is freed + automatically as the code block is left: + + { + __attribute__((cleanup(sd_event_unrefp)) sd_event *event = NULL; + int r; + … + r = sd_event_default(&event); + if (r < 0) + fprintf(stderr, "Failed to allocate event loop: %s\n", strerror(-r)); + … +} + + sd_event_ref(), + sd_event_unref() and + sd_event_unrefp() execute no operation if the passed in event loop object is NULL. sd_event_get_tid() retrieves the thread diff --git a/man/sd_event_source_unref.xml b/man/sd_event_source_unref.xml index 579ec47e8e..2c4d450763 100644 --- a/man/sd_event_source_unref.xml +++ b/man/sd_event_source_unref.xml @@ -44,6 +44,7 @@ sd_event_source_unref + sd_event_source_unrefp sd_event_source_ref Increase or decrease event source reference counters @@ -58,6 +59,11 @@ sd_event_source *source + + void sd_event_source_unrefp + sd_event_source **source + + sd_event_source* sd_event_source_ref sd_event_source *source @@ -80,12 +86,23 @@ the reference counter reaches zero it is removed from its event loop object and destroyed. + sd_event_source_unrefp() is similar to + sd_event_source_unref() but takes a pointer to a + pointer to an sd_event_source object. This call is useful in + conjunction with GCC's and LLVM's Clean-up + Variable Attribute. Note that this function is defined as + inline function. + sd_event_source_ref() may be used to increase by one the reference counter of the event source object specified as source. - Both functions execute no operation if the passed event - source object is NULL. + sd_event_source_unref(), + sd_bus_creds_unrefp() and + sd_bus_creds_ref() execute no operation if + the passed event source object is + NULL. Note that event source objects stay alive and may be dispatched as long as they have a reference counter greater than diff --git a/man/sd_login_monitor_new.xml b/man/sd_login_monitor_new.xml index db21d70252..5625ab9207 100644 --- a/man/sd_login_monitor_new.xml +++ b/man/sd_login_monitor_new.xml @@ -45,6 +45,7 @@ sd_login_monitor_new sd_login_monitor_unref + sd_login_monitor_unrefp sd_login_monitor_flush sd_login_monitor_get_fd sd_login_monitor_get_events @@ -68,6 +69,11 @@ sd_login_monitor *m + + void sd_login_monitor_unrefp + sd_login_monitor **m + + int sd_login_monitor_flush sd_login_monitor *m @@ -121,6 +127,26 @@ descriptor returned by sd_login_monitor_get_fd(). + sd_login_monitor_unrefp() is similar to + sd_login_monitor_unref() but takes a pointer + to a pointer to an sd_login_monitor object. This call + is useful in conjunction with GCC's and LLVM's Clean-up + Variable Attribute. Note that this function is defined as + inline function. Use a declaration like the following, in order to + allocate a login monitor object that is freed automatically as the + code block is left: + + { + __attribute__((cleanup(sd_login_monitor_unrefp)) sd_login_monitor *m = NULL; + int r; + … + r = sd_login_monitor_default(&m); + if (r < 0) + fprintf(stderr, "Failed to allocate login monitor object: %s\n", strerror(-r)); + … +} + sd_login_monitor_flush() may be used to reset the wakeup state of the monitor object. Whenever an event causes the monitor to wake up the event loop via the file @@ -128,6 +154,11 @@ state. If this call is not invoked, the file descriptor will immediately wake up the event loop again. + sd_login_monitor_unref() and + sd_login_monitor_unrefp() execute no + operation if the passed in monitor object is + NULL. + sd_login_monitor_get_fd() may be used to retrieve the file descriptor of the monitor object that may be integrated in an application defined event loop, based around -- cgit v1.2.3-54-g00ecf