[websockets_cci=no])
AC_MSG_RESULT([$websockets_cci])
+ # Check for ssl_cipher_list in context creation info
+ if test "$websockets_cci" = "yes"; then
+ AC_MSG_CHECKING([for WEBSOCKETS cipher list support])
+ AC_LINK_IFELSE(
+ [AC_LANG_PROGRAM(
+ [[#include <stdlib.h>
+ #include <libwebsockets.h>]],
+ [[struct libwebsocket_context *ctx;
+ void *ptr;
+ ptr = &ctx->ssl_cipher_list;]])],
+ [websockets_cipherlist=yes],
+ [websockets_cipherlist=no])
+ AC_MSG_RESULT([$websockets_cipherlist])
+ fi
+
+ # Check for pollargs struct support
+ if test "$websockets_cci" = "yes"; then
+ AC_MSG_CHECKING([for WEBSOCKETS pollargs support])
+ AC_LINK_IFELSE(
+ [AC_LANG_PROGRAM(
+ [[#include <stdlib.h>
+ #include <libwebsockets.h>]],
+ [[struct libwebsocket_pollargs = NULL;]])],
+ [websockets_passfd=pollargs],
+ [websockets_passfd=no])
+ AC_MSG_RESULT([$websockets_passfd])
+ else
+ websockets_passfd=no
+ fi
+
+ # Argh... try to detect the poll fd passing API...
+ if test "$websocket_passfd" != "pollargs"; then
+ AC_MSG_CHECKING([for WEBSOCKETS POLL fd passing API])
+ AC_LINK_IFELSE(
+ [AC_LANG_PROGRAM(
+ [[#include <stdlib.h>
+ #include <libwebsockets.h>]],
+ [[printf("%d\n", LWS_MAX_HEADER_NAME_LENGTH);]])],
+ [websockets_passfd=user],
+ [websockets_passfd=in])
+ AC_MSG_RESULT([$websockets_passfd])
+ fi
+
# Check for new libwebsockets_get_internal_extensions.
AC_MSG_CHECKING([for WEBSOCKETS internal extension query API])
AC_LINK_IFELSE(
if test "$websockets_cci" = "yes"; then
WEBSOCKETS_CFLAGS="$WEBSOCKETS_CFLAGS -DWEBSOCKETS_CONTEXT_INFO"
fi
+ if test "$websockets_cipherlist" = "yes"; then
+ WEBSOCKETS_CFLAGS="$WEBSOCKETS_CFLAGS -DWEBSOCKETS_CIPHER_LIST"
+ fi
+ if test "$websockets_passfd" = "pollargs"; then
+ WEBSOCKETS_CFLAGS="$WEBSOCKETS_CFLAGS -DWEBSOCKETS_PASSFD_POLLARGS"
+ else
+ if test "$websockets_passfd" = "in"; then
+ WEBSOCKETS_CFLAGS="$WEBSOCKETS_CFLAGS -DWEBSOCKETS_PASSFD_IN"
+ else
+ WEBSOCKETS_CFLAGS="$WEBSOCKETS_CFLAGS -DWEBSOCKETS_PASSFD_USER"
+ fi
+ fi
+
if test "$websockets_query_ext" = "yes"; then
WEBSOCKETS_CFLAGS="$WEBSOCKETS_CFLAGS -DWEBSOCKETS_QUERY_EXTENSIONS"
fi
cci.ssl_cert_filepath = cfg->ssl_cert;
cci.ssl_private_key_filepath = cfg->ssl_pkey;
cci.ssl_ca_filepath = cfg->ssl_ca;
+#ifdef WEBSOCKETS_CIPHER_LIST
cci.ssl_cipher_list = cfg->ssl_ciphers;
+#else
+ if (cfg->ssl_ciphers != NULL) {
+ mrp_log_error("setting libwebsockets cipher list not supported");
+ errno = EOPNOTSUPP;
+ return NULL;
+ }
+#endif
cci.options = 0;
cci.ka_time = cfg->timeout;
#endif
+static int getpollfd(void *user, void *in, size_t len, int *fd, int *mask)
+{
+#if defined WEBSOCKETS_PASSFD_POLLARGS
+ struct libwebsocket_pollargs *args;
+
+ MRP_UNUSED(user);
+ MRP_UNUSED(in);
+
+ args = (struct libwebsocket_pollargs *)in;
+
+ *fd = args->fd;
+ if (mask != NULL)
+ *mask = args->events;
+
+#elif defined WEBSOCKETS_PASSFD_IN
+ static int misdetected = 0;
+ int ufd = (ptrdiff_t)user;
+
+ if (!misdetected) {
+ *fd = (ptrdiff_t)in;
+ if (mask != NULL)
+ *mask = (int)len;
+
+ if (0 < ufd && ufd < 4096) {
+ misdetected = 1;
+ mrp_log_error("*** websockets fd passing convention misdetected.");
+ mrp_log_error("*** fixing it up...");
+ goto fixup;
+ }
+ }
+ else {
+ fixup:
+
+ *fd = ufd;
+ if (mask != NULL)
+ *mask = (int)len;
+ }
+
+#else
+ MRP_UNUSED(in);
+
+ *fd = (ptrdiff_t)user;
+ if (mask != NULL)
+ *mask = (int)len;
+
+#endif
+
+ if (*fd != 0)
+ return 0;
+ else
+ return -1;
+}
+
static int http_event(lws_ctx_t *ws_ctx, lws_t *ws, lws_event_t event,
void *user, void *in, size_t len)
const char *ext, *uri;
int fd, mask, status, accepted;
+ mrp_debug("ctx: %p, ws: %p, event: %d, user: %p, in: %p, len: %zd",
+ ws_ctx, ws, event, user, in, len);
+
switch (event) {
case LWS_CALLBACK_ESTABLISHED:
mrp_debug("client-handshake completed on websocket %p/%p", ws, user);
#else /* WEBSOCKETS_CHANGE_MODE_POLL_FD */
case LWS_CALLBACK_ADD_POLL_FD:
-#ifdef WEBSOCKETS_CONTEXT_INFO /* just brilliant... */
+ getpollfd(user, in, len, &fd, &mask);
+#if 0
+ /* just brilliant... */
+#if defined(WEBSOCKETS_CONTEXT_INFO) && defined(WEBSOCKETS_CIPHER_LIST)
fd = (ptrdiff_t)in;
#else
fd = (ptrdiff_t)user;
#endif
mask = (int)len;
+#endif
+
mrp_debug("start polling fd %d for events 0x%x", fd, mask);
if (add_fd(ctx, fd, mask))
return LWS_EVENT_OK;
return LWS_EVENT_ERROR;
case LWS_CALLBACK_DEL_POLL_FD:
-#ifdef WEBSOCKETS_CONTEXT_INFO /* just brilliant... */
+ getpollfd(user, in, len, &fd, NULL);
+#if 0
+ /* just brilliant... */
+#if defined(WEBSOCKETS_CONTEXT_INFO) && defined(WEBSOCKETS_CIPHER_LIST)
fd = (ptrdiff_t)in;
#else
fd = (ptrdiff_t)user;
+#endif
#endif
mrp_debug("stop polling fd %d", fd);
if (del_fd(ctx, fd))
return LWS_EVENT_ERROR;
case LWS_CALLBACK_SET_MODE_POLL_FD:
-#ifdef WEBSOCKETS_CONTEXT_INFO /* just brilliant... */
+ getpollfd(user, in, len, &fd, &mask);
+#if 0
+ /* just brilliant... */
+#if defined(WEBSOCKETS_CONTEXT_INFO) && defined(WEBSOCKETS_CIPHER_LIST)
fd = (ptrdiff_t)in;
#else
fd = (ptrdiff_t)user;
#endif
mask = (int)len;
+#endif
mrp_debug("enable poll events 0x%x for fd %d", mask, fd);
if (mod_fd(ctx, fd, mask, FALSE))
return LWS_EVENT_OK;
return LWS_EVENT_ERROR;
case LWS_CALLBACK_CLEAR_MODE_POLL_FD:
-#ifdef WEBSOCKETS_CONTEXT_INFO /* just brilliant... */
+ getpollfd(user, in, len, &fd, &mask);
+#if 0
+ /* just brilliant... */
+#if defined(WEBSOCKETS_CONTEXT_INFO) && defined(WEBSOCKETS_CIPHER_LIST)
fd = (ptrdiff_t)in;
#else
fd = (ptrdiff_t)user;
#endif
mask = (int)len;
+#endif
mrp_debug("disable poll events 0x%x for fd %d", mask, fd);
if (mod_fd(ctx, fd, mask, TRUE))
return LWS_EVENT_OK;
#define RSET_REQUEST "request"
#define RSET_RELEASE "release"
#define RSET_DELETE "delete"
+#define RSET_RELEASING "releasing"
#define RESOURCE_SET_PROPERTY "setProperty"
#define RESOURCE_GET_PROPERTIES "getProperties"
mrp_log_info("Event for %s: grant 0x%08x, advice 0x%08x",
rset->path, grant, advice);
+ if (mrp_get_resource_set_state(rset->set) == mrp_resource_pending_release) {
+ update_property(rset->status_prop, "releasing");
+ return;
+ }
+
if (!rset->set || !rset->committed) {
struct deferred_rset_data_s *r_data =
mrp_dbus_remove_method(ctx->dbus, rset->path, RSET_IFACE, RSET_DELETE,
rset_cb, ctx);
+ mrp_dbus_remove_method(ctx->dbus, rset->path, RSET_IFACE, RSET_RELEASING,
+ rset_cb, ctx);
mrp_dbus_remove_method(ctx->dbus, rset->path, RSET_IFACE, RSET_RELEASE,
rset_cb, ctx);
mrp_dbus_remove_method(ctx->dbus, rset->path, RSET_IFACE, RSET_REQUEST,
mrp_dbus_send_msg(dbus, reply);
mrp_dbus_msg_unref(reply);
}
+ else if (strcmp(member, RSET_RELEASING) == 0) {
+
+ mrp_log_info("Releasing cb rset %s", path);
+
+ mrp_resource_set_did_release(rset->set,0);
+
+ reply = mrp_dbus_msg_method_return(dbus, msg);
+
+ if (!reply)
+ goto error;
+
+ mrp_dbus_send_msg(dbus, reply);
+ mrp_dbus_msg_unref(reply);
+ }
else if (strcmp(member, RSET_SET_PROPERTY) == 0) {
char *name = NULL;
char *value = NULL;
destroy_rset(rset);
goto error_reply;
}
+ if (!mrp_dbus_export_method(ctx->dbus, rset->path,
+ RSET_IFACE, RSET_RELEASING, rset_cb, ctx)) {
+ destroy_rset(rset);
+ goto error_reply;
+ }
mrp_htbl_insert(ctx->mgr->rsets, (void *) rset->path, rset);
update_property(ctx->mgr->rsets_prop, htbl_keys(ctx->mgr->rsets));
case MRP_RES_RESOURCE_PENDING:
state = "pending";
break;
+ case MRP_RES_RESOURCE_ABOUT_TO_LOOSE:
+ state = "about to loose";
+ break;
}
return state;
}
switch (mask_type) {
case 0: expected_tag = RESPROTO_RESOURCE_GRANT; break;
case 1: expected_tag = RESPROTO_RESOURCE_ADVICE; break;
+ case 2: expected_tag = RESPROTO_RESOURCE_PENDING; break;
default: /* don't know what to fetch */ return false;
}
return true;
}
+bool fetch_resource_sync_release(mrp_msg_t *msg, void **pcursor,
+ bool *psync_release)
+{
+ uint16_t tag;
+ uint16_t type;
+ mrp_msg_value_t value;
+ size_t size;
+
+ if (!mrp_msg_iterate(msg, pcursor, &tag, &type, &value, &size) ||
+ tag != RESPROTO_RESOURCE_SYNC_RELEASE || type != MRP_MSG_FIELD_BOOL)
+ {
+ *psync_release = false;
+ return false;
+ }
+
+ *psync_release = value.bln;
+ return true;
+}
+
static int priv_res_to_mrp_res(uint32_t id, resource_def_t *src, mrp_res_resource_t *dst,
mrp_res_resource_set_t *set)
dst->priv->server_id = id;
+ dst->priv->sync_release = src->sync_release;
dst->priv->num_attributes = src->num_attrs;
dst->priv->attrs = src->attrs;
dst->priv->set = set;
while (fetch_resource_name(msg, pcursor, &rdef[dim].name)) {
int n_attrs = 0;
+ if (!fetch_resource_sync_release(msg, pcursor, &rdef[dim].sync_release)) {
+ goto failed;
+ }
+
if (!fetch_attribute_array(msg, pcursor, ATTRIBUTE_MAX+1,
attrs, &n_attrs))
goto failed;
return -1;
}
+int did_release_resource_set_request(mrp_res_context_t *cx,
+ mrp_res_resource_set_t *rset)
+{
+ mrp_msg_t *msg = NULL;
+
+ if (!cx->priv->connected)
+ return -1;
+
+ msg = mrp_msg_create(
+ RESPROTO_SEQUENCE_NO, MRP_MSG_FIELD_UINT32, cx->priv->next_seqno,
+ RESPROTO_REQUEST_TYPE, MRP_MSG_FIELD_UINT16,
+ RESPROTO_DID_RELEASE_RESOURCE_SET,
+ RESPROTO_RESOURCE_SET_ID, MRP_MSG_FIELD_UINT32, rset->priv->id,
+ RESPROTO_MESSAGE_END);
+
+ if (!msg)
+ return -1;
+
+ rset->priv->seqno = cx->priv->next_seqno;
+ cx->priv->next_seqno++;
+
+ if (!mrp_transport_send(cx->priv->transp, msg))
+ goto error;
+
+ mrp_msg_unref(msg);
+ return 0;
+
+error:
+ mrp_msg_unref(msg);
+ return -1;
+}
+
int create_resource_set_request(mrp_res_context_t *cx,
mrp_res_resource_set_t *rset)
int get_available_resources_request(mrp_res_context_t *cx);
+int did_release_resource_set_request(mrp_res_context_t *cx,
+ mrp_res_resource_set_t *rset);
+
+
#endif
MRP_RES_RESOURCE_PENDING,
MRP_RES_RESOURCE_ACQUIRED,
MRP_RES_RESOURCE_AVAILABLE,
+ MRP_RES_RESOURCE_ABOUT_TO_LOOSE,
} mrp_res_resource_state_t;
typedef enum {
*/
int mrp_res_acquire_resource_set(const mrp_res_resource_set_t *rs);
+/**
+ * Prototype for a callback that will be called
+ * when the client is asked to free the resources.
+ * Upon returning from this callback, the client must
+ * stop using the resource and clean up the infrastructure
+ * related to it, e.g. close opened devices.
+ *
+ * @param cx murphy connection context.
+ * @param set resource set with the resources you must free.
+ * @param userdata data you gave when setting the release callback.
+ */
+typedef void (*mrp_res_resource_release_callback_t) (mrp_res_context_t *cx,
+ const mrp_res_resource_set_t *rs,
+ void *userdata);
+
+/**
+ * Set the resource release callback.
+ * This callback will be called to ask client to free the resources.
+ *
+ * @param rs resource set to update.
+ * @param release_cb resource release callback.
+ * @param userdata data you want to access in resource release callback.
+ *
+ * @return true if the release callback was set successfully, false - otherwise.
+ */
+bool mrp_res_set_release_callback(const mrp_res_resource_set_t *rs,
+ mrp_res_resource_release_callback_t release_cb,
+ void *userdata);
+
/**
* Release a resource set. Releasing a set of resources
* will not stop delivery of Resource callbacks for that
*/
int mrp_res_release_resource_set(mrp_res_resource_set_t *rs);
-
/**
* Get a resource set unique server-side id. The id information is
* normally available only after mrp_res_acquire_resource_set or
typedef struct {
const char *name;
+ bool sync_release;
int num_attrs;
mrp_res_attribute_t *attrs;
} resource_def_t;
mrp_res_resource_t *pub; /* composition */
mrp_res_resource_set_t *set; /* owning set */
+ bool sync_release;
bool mandatory;
bool shared;
int num_attributes;
bool autorelease;
mrp_res_resource_callback_t cb;
+ mrp_res_resource_release_callback_t release_cb;
void *user_data;
+ void *release_cb_user_data;
uint32_t num_resources;
mrp_res_resource_t **resources;
void **pcursor)
{
uint32_t rset_id;
- uint32_t grant, advice;
+ uint32_t grant, advice, pending;
mrp_resproto_state_t state;
uint16_t tag;
uint16_t type;
uint32_t mask, all = 0x0, mandatory = 0x0;
uint32_t i;
mrp_res_resource_set_t *rset;
+ bool should_release_resource;
mrp_res_info("Resource event (request no %u):", seqno);
if (!fetch_resource_set_id(msg, pcursor, &rset_id) ||
!fetch_resource_set_state(msg, pcursor, &state) ||
!fetch_resource_set_mask(msg, pcursor, 0, &grant) ||
- !fetch_resource_set_mask(msg, pcursor, 1, &advice)) {
+ !fetch_resource_set_mask(msg, pcursor, 1, &advice) ||
+ !fetch_resource_set_mask(msg, pcursor, 2, &pending)) {
mrp_res_error("failed to fetch data from message");
goto ignore;
}
if (grant & mask) {
res->state = MRP_RES_RESOURCE_ACQUIRED;
}
+ else if (pending & mask) {
+ res->state = MRP_RES_RESOURCE_ABOUT_TO_LOOSE;
+ }
else {
res->state = MRP_RES_RESOURCE_LOST;
}
mrp_res_info("advice = 0x%08x, grant = 0x%08x, mandatory = 0x%08x, all = 0x%08x",
advice, grant, mandatory, all);
- if (grant) {
+ should_release_resource = false;
+ if (pending) {
+ rset->state = MRP_RES_RESOURCE_ABOUT_TO_LOOSE;
+ should_release_resource = true;
+ }
+ else if (grant) {
rset->state = MRP_RES_RESOURCE_ACQUIRED;
}
else if (advice == mandatory) {
print_resource_set(rset);
#endif
if (!rset->priv->seqno) {
- if (rset->priv->cb) {
- increase_ref(cx, rset);
+ increase_ref(cx, rset);
+ if (should_release_resource) {
+ if (rset->priv->release_cb) {
+ rset->priv->release_cb(cx, rset, rset->priv->release_cb_user_data);
+ }
+ }
+ else if (rset->priv->cb) {
rset->priv->cb(cx, rset, rset->priv->user_data);
- decrease_ref(cx, rset);
+ }
+ decrease_ref(cx, rset);
+
+ if (should_release_resource) {
+ did_release_resource_set_request(cx, rset);
}
}
break;
}
+ case RESPROTO_DID_RELEASE_RESOURCE_SET:
+ {
+ mrp_res_resource_set_t *rset;
+ mrp_res_info("received DID_RELEASE_RESOURCE_SET response");
+
+ rset = acquire_resource_set_response(msg, cx, &cursor);
+
+ if (!rset) {
+ goto error;
+ }
+
+ rset->priv->seqno = 0;
+
+ break;
+ }
case RESPROTO_RESOURCES_EVENT:
mrp_res_info("received RESOURCES_EVENT response");
case MRP_RES_RESOURCE_PENDING:
state = "pending";
break;
+ case MRP_RES_RESOURCE_ABOUT_TO_LOOSE:
+ state = "about to loose";
+ break;
}
return state;
}
rset->priv->resources = resources;
rset->priv->num_resources = num_resources;
rset->priv->autorelease = original->priv->autorelease;
+ rset->priv->release_cb = original->priv->release_cb;
+ rset->priv->release_cb_user_data = original->priv->release_cb_user_data;
return 0;
goto error;
res->priv->server_id = server_id;
+ res->priv->sync_release = proto->priv->sync_release;
res->priv->mandatory = mandatory;
res->priv->shared = shared;
res->priv->pub = res;
return cx->priv->master_resource_set;
}
-
int mrp_res_release_resource_set(mrp_res_resource_set_t *original)
{
mrp_res_resource_set_t *internal_set = NULL;
return TRUE;
}
+bool mrp_res_set_release_callback(const mrp_res_resource_set_t *rs,
+ mrp_res_resource_release_callback_t release_cb,
+ void *userdata)
+{
+ bool result = false;
+ mrp_res_resource_t *resource;
+ uint32_t i;
-int mrp_res_acquire_resource_set(
- const mrp_res_resource_set_t *original)
+ if (rs && rs->state == MRP_RES_RESOURCE_PENDING) {
+ for (i = 0; i < rs->priv->num_resources; i++) {
+ resource = rs->priv->resources[i];
+ if (resource->priv->sync_release) {
+ result = true;
+ rs->priv->release_cb = release_cb;
+ rs->priv->release_cb_user_data = userdata;
+ break;
+ }
+ }
+ }
+
+ return result;
+}
+
+static mrp_res_resource_set_t *acquire_resource_set(const mrp_res_resource_set_t *original)
{
- mrp_res_resource_set_t *rset;
+ mrp_res_resource_set_t *rset = NULL;
+
mrp_res_context_t *cx = original->priv->cx;
if (!cx->priv->connected) {
goto error;
}
+ if (!original->priv->release_cb) {
+ for (uint32_t i = 0; i < original->priv->num_resources; i++) {
+ if (original->priv->resources[i]->priv->sync_release) {
+ mrp_res_error("release callback is not set");
+ goto error;
+ }
+ }
+ }
+
rset = mrp_htbl_lookup(cx->priv->internal_rset_mapping,
u_to_p(original->priv->internal_id));
}
else {
/* re-acquire a lost or released set */
- return acquire_resource_set_request(cx, rset);
+ acquire_resource_set_request(cx, rset);
}
}
else {
}
}
- return 0;
+ return rset;
error:
mrp_log_error("error acquiring a resource set");
- return -1;
+ return NULL;
+}
+
+int mrp_res_acquire_resource_set(
+ const mrp_res_resource_set_t *original)
+{
+ int result = -1;
+
+ if (acquire_resource_set(original)) {
+ result = 0;
+ }
+
+ return result;
}
for (i = 0; zone_names[i]; i++)
printf(" %s\n", zone_names[i]);
-
mrp_free(zone_names);
}
}
mrp_plugin_t *plugin = data->plugin;
const char **names;
mrp_attr_t *attrs;
+ bool sync_release;
mrp_attr_t buf[ATTRIBUTE_MAX];
uint32_t resid;
for (resid = 0; names[resid]; resid++) {
attrs = mrp_resource_definition_read_all_attributes(
resid, ATTRIBUTE_MAX, buf);
+ sync_release = mrp_resource_definition_get_sync_release(resid);
if (!PUSH(req, RESOURCE_NAME, STRING, names[resid]) ||
+ !PUSH(req, RESOURCE_SYNC_RELEASE, BOOL, sync_release) ||
!write_attributes(req, attrs))
goto failed;
}
mrp_resource_set_release(rset, seqno);
}
+static void did_release_resource_set_request(client_t *client, mrp_msg_t *req,
+ uint32_t seqno, void **pcurs)
+{
+ uint16_t tag;
+ uint16_t type;
+ size_t size;
+ mrp_msg_value_t value;
+ uint32_t rset_id;
+ mrp_resource_set_t *rset;
+
+ MRP_ASSERT(client, "invalid argument");
+ MRP_ASSERT(client->rscli, "confused with data structures");
+
+ if (!mrp_msg_iterate(req, pcurs, &tag, &type, &value, &size) ||
+ tag != RESPROTO_RESOURCE_SET_ID || type != MRP_MSG_FIELD_UINT32)
+ {
+ reply_with_status(client, req, EINVAL);
+ return;
+ }
+
+ rset_id = value.u32;
+
+ if (!(rset = mrp_resource_client_find_set(client->rscli, rset_id))) {
+ reply_with_status(client, req, ENOENT);
+ return;
+ }
+
+ reply_with_status(client, req, 0);
+
+ mrp_resource_set_did_release(rset, seqno);
+}
+
static void connection_evt(mrp_transport_t *listen, void *user_data)
{
static uint32_t id;
acquire_resource_set_request(client, msg, seqno, false, &cursor);
break;
+ case RESPROTO_DID_RELEASE_RESOURCE_SET:
+ did_release_resource_set_request(client, msg, seqno, &cursor);
+ break;
+
default:
mrp_log_warning("%s: unsupported request type %d",
plugin->instance, reqtyp);
uint16_t state;
mrp_resource_mask_t grant;
mrp_resource_mask_t advice;
+ mrp_resource_mask_t pending;
mrp_resource_mask_t mask;
mrp_resource_mask_t all;
mrp_msg_t *msg;
id = mrp_get_resource_set_id(rset);
grant = mrp_get_resource_set_grant(rset);
advice = mrp_get_resource_set_advice(rset);
+ pending = mrp_get_resource_set_pending_release(rset);
if (mrp_get_resource_set_state(rset) == mrp_resource_acquire)
state = RESPROTO_ACQUIRE;
FIELD( RESOURCE_STATE , UINT16, state ),
FIELD( RESOURCE_GRANT , UINT32, grant ),
FIELD( RESOURCE_ADVICE, UINT32, advice ),
+ FIELD( RESOURCE_PENDING, UINT32, pending ),
RESPROTO_MESSAGE_END );
if (!msg)
mrp_attr_t *attrs, *a;
mrp_attr_t buf[ATTRIBUTE_MAX];
uint32_t id;
+ bool sync_release;
if (!mrp_json_get_integer(req, "seq", &seq)) {
ignore_invalid_request(c, req, "missing 'seq' field");
if (!mrp_json_add_string (r, "name", resources[id]))
goto fail;
+ sync_release = mrp_resource_definition_get_sync_release(id);
+ if (!mrp_json_add_boolean(r, "sync_release", sync_release))
+ goto fail;
+
attrs = mrp_resource_definition_read_all_attributes(id,
ATTRIBUTE_MAX, buf);
mrp_json_t *msg, *rarr, *r;
int rsid;
const char *state;
- int grant, advice, all, mask;
+ int grant, pending_release, pending_acquire, advice, all, mask;
errbuf_t e;
mrp_resource_t *res;
void *it;
return;
}
- if (mrp_get_resource_set_state(rset) == mrp_resource_acquire)
+ pending_release = (int)mrp_get_resource_set_pending_release(rset);
+ pending_acquire = (int)mrp_get_resource_set_pending_acquire(rset);
+
+ if (pending_acquire && !pending_release) {
+ mrp_debug("not emitting event for resource set that is pending acquisition");
+ return;
+ }
+ else if (mrp_get_resource_set_state(rset) == mrp_resource_acquire)
state = RESWRT_STATE_GRANTED;
else
state = RESWRT_STATE_RELEASE;
- rsid = (int)mrp_get_resource_set_id(rset);
- grant = (int)mrp_get_resource_set_grant(rset);
- advice = (int)mrp_get_resource_set_advice(rset);
+ rsid = (int)mrp_get_resource_set_id(rset);
+ grant = (int)mrp_get_resource_set_grant(rset);
+ advice = (int)mrp_get_resource_set_advice(rset);
msg = alloc_reply(type, seq);
rarr = r = NULL;
- if (mrp_json_add_integer(msg, "id" , rsid ) &&
- mrp_json_add_string (msg, "state" , state) &&
- mrp_json_add_integer(msg, "grant" , grant) &&
- mrp_json_add_integer(msg, "advice", advice)) {
+ if (mrp_json_add_integer(msg, "id" , rsid ) &&
+ mrp_json_add_string (msg, "state" , state ) &&
+ mrp_json_add_integer(msg, "grant" , grant ) &&
+ mrp_json_add_integer(msg, "pending" , pending_release) &&
+ mrp_json_add_integer(msg, "advice" , advice)) {
all = grant | advice;
it = NULL;
}
+static void did_release_set(wrt_client_t *c, mrp_json_t *req)
+{
+ const char *type = RESWRT_DID_RELEASE_SET;
+ int seq;
+ mrp_json_t *reply;
+ mrp_resource_set_t *rset;
+ uint32_t rsid;
+
+ if (!mrp_json_get_integer(req, "seq", &seq)) {
+ ignore_invalid_request(c, req, "missing 'seq' field");
+ return;
+ }
+
+ /* get resource set id */
+ if (!mrp_json_get_integer(req, "id", &rsid)) {
+ error_reply(c, type, seq, EINVAL, "missing id");
+ return;
+ }
+
+ rset = mrp_resource_client_find_set(c->rsc, rsid);
+
+ if (rset != NULL) {
+ reply = alloc_reply(type, seq);
+
+ if (reply != NULL) {
+ if (mrp_json_add_integer(reply, "status", 0))
+ send_message(c, reply);
+ }
+
+ mrp_resource_set_did_release(rset, (uint32_t)seq);
+ }
+ else
+ error_reply(c, type, seq, ENOENT, "resource set %d not found", rsid);
+}
+
+
static wrt_client_t *create_client(wrt_data_t *data, mrp_transport_t *lt)
{
wrt_client_t *c;
acquire_set(c, req);
else if (!strcmp(type, RESWRT_RELEASE_SET))
release_set(c, req);
+ else if (!strcmp(type, RESWRT_DID_RELEASE_SET))
+ did_release_set(c, req);
else
ignore_unknown_request(c, req, type);
}
}
+/** Map resource definitions to names. */
+WrtResourceManager.prototype.map_resources_by_name = function (resources) {
+ if (this.resource_by_name) {
+ return;
+ }
+
+ this.resource_by_name = {};
+
+ for (var i in resources) {
+ var resource = resources[i];
+ var name = resource.name;
+ this.resource_by_name[name] = {
+ sync_release: resource.sync_release,
+ attributes: resource.attributes,
+ };
+ }
+}
+
+
/** Resource set constructor. */
function WrtResourceSet (mgr, reqno) {
this.manager = mgr;
if (!this.resources)
this.resources = msg.resources;
- this.state = msg.state;
- this.grant = msg.grant;
- this.advice = msg.advice;
+ this.state = msg.state;
+ this.grant = msg.grant;
+ this.pending = msg.pending;
+ this.advice = msg.advice;
- if (this.onstatechanged)
- this.onstatechanged(this.grant);
+ if (this.pending) {
+ if (this.onrelease) {
+ this.onrelease(this.grant);
+ }
+ this.didRelease();
+ }
+ else if (this.onstatechanged) {
+ this.onstatechanged(this.pending);
+ }
}
else if (type == 'create') {
var status = msg.status;
}
+/** The resource set was freed by client. */
+WrtResourceSet.prototype.didRelease = function () {
+ this.manager.send_request({ type: 'did_release', id: this.id });
+}
+
+
/** Map resources to names. */
WrtResourceSet.prototype.ensure_resource_map = function () {
var r;
}
+/** Check if the resource set release callback is present if it is needed. */
+WrtResourceSet.prototype.isReleaseCallbackOK = function () {
+ var result = true;
+
+ if (!this.onrelease) {
+ for (var i in this.resources) {
+ var name = this.resources[i].name;
+ if (this.manager.resource_by_name[name].sync_release) {
+ result = false;
+ break;
+ }
+ }
+ }
+
+ return result;
+}
+
+
/** Pending request constructor. */
function WrtPendingRequest (mgr, reqno) {
this.manager = mgr;
if (status == 0) {
if (this.onsuccess && (m = evtmap[msg.type])) {
event = m.map ? m.map(msg[m.field]) : msg[m.field];
+
+ if ('resources' == m.field) {
+ this.manager.map_resources_by_name(msg.resources);
+ }
+
this.onsuccess(event);
}
}
/** Acquire the resource set. */
WrtResourceSet.prototype.acquire = function () {
- this.manager.send_request({ type: 'acquire', id: this.id });
+ if (this.isReleaseCallbackOK()) {
+ this.manager.send_request({ type: 'acquire', id: this.id });
+ }
+ else {
+ throw new WrtResourceError("Release callback is not set when it should be.");
+ }
}
}
+/** Check if the named resource is pending for release/acqusition. */
+WrtResourceSet.prototype.isPending = function (name) {
+ this.ensure_resource_map();
+
+ r = this.resource_by_name[name];
+
+ if (this.pending & r.mask)
+ return true;
+ else
+ return false;
+}
+
+
/** Check if the named resource can be allocated. */
WrtResourceSet.prototype.isAllocable = function (name) {
this.ensure_resource_map();
rset.onsuccess = resourceSetCreated;
rset.onerror = resourceSetFailed;
rset.onstatechanged = resourceSetEvent;
+ rset.onrelease = function (grant) {
+ var names = this.getResourceNames();
+ for (var i in names) {
+ if (this.isPending(names[i])) {
+ console.log("Resource '" + names[i] + "' must be released.");
+ }
+ }
+
+ window.alert("Resource must be released!!");
+
+ if (this.isPending('audio_playback')) {
+ stopAudio();
+ }
+ };
}
catch (e) {
console.log("Query failed: " +
#define RESWRT_DESTROY_SET "destroy"
#define RESWRT_ACQUIRE_SET "acquire"
#define RESWRT_RELEASE_SET "release"
+#define RESWRT_DID_RELEASE_SET "did_release"
#define RESWRT_EVENT "event"
#define RESWRT_STATE_GRANTED "acquire"
mrp_resource_definition_read_all_attributes(uint32_t resource_id,
uint32_t buflen,
mrp_attr_t *buf);
+bool mrp_resource_definition_get_sync_release(uint32_t resource_id);
const char **mrp_application_class_get_all_names(uint32_t buflen,
const char **buf);
void *user_data);
void mrp_resource_set_destroy(mrp_resource_set_t *resource_set);
+
uint32_t mrp_get_resource_set_id(mrp_resource_set_t *resource_set);
mrp_resource_state_t
mrp_resource_mask_t
mrp_get_resource_set_advice(mrp_resource_set_t *resource_set);
+mrp_resource_mask_t
+mrp_get_resource_set_pending_release(mrp_resource_set_t *resource_set);
+
+mrp_resource_mask_t
+mrp_get_resource_set_pending_acquire(mrp_resource_set_t *resource_set);
+
mrp_resource_client_t *
mrp_get_resource_set_client(mrp_resource_set_t *resource_set);
void mrp_resource_set_release(mrp_resource_set_t *resource_set,
uint32_t request_id);
+void mrp_resource_set_did_release(mrp_resource_set_t *resource_set,
+ uint32_t request_id);
+
mrp_resource_t *
mrp_resource_set_iterate_resources(mrp_resource_set_t *resource_set,void **it);
PRIORITY,
SHAREABLE,
MANDATORY,
+ SYNC_RELEASE,
MODAL,
SHARE,
GRANT,
const char *name = NULL;
mrp_attr_def_t *attrs = NULL;
bool shareable = false;
+ bool sync_release = false;
mrp_resource_mgr_ftbl_t *ftbl = NULL;
void *mgrdata = NULL;
attr_def_t *adef;
shareable = lua_toboolean(L, -1);
break;
+ case SYNC_RELEASE:
+ luaL_argcheck(L, lua_isboolean(L,-1), 2, "attempt to assign "
+ "non-boolean value to 'sync_release' field");
+ sync_release = lua_toboolean(L, -1);
+ break;
+
+
case ATTRIBUTES:
attrs = check_attrdefs(L, -1, &nattr);
break;
if (!name)
luaL_error(L, "missing or wrong name field");
- id = mrp_resource_definition_create(name, shareable, attrs,ftbl,mgrdata);
+ id = mrp_resource_definition_create_with_sync_release(name, shareable, sync_release, attrs,ftbl,mgrdata);
MRP_ASSERT(id < MRP_RESOURCE_MAX, "resource id is out of range");
lua_pushnil(L);
else {
switch (fld) {
- case NAME: lua_pushstring(L, rd->name); break;
- case ID: lua_pushinteger(L, rd->id + 1); break;
- case SHAREABLE: lua_pushboolean(L, rd->shareable); break;
- default: lua_pushnil(L); break;
+ case NAME: lua_pushstring(L, rd->name); break;
+ case ID: lua_pushinteger(L, rd->id + 1); break;
+ case SHAREABLE: lua_pushboolean(L, rd->shareable); break;
+ case SYNC_RELEASE: lua_pushboolean(L, rd->sync_release); break;
+ default: lua_pushnil(L); break;
}
}
return ATTRIBUTES;
break;
+ case 12:
+ if (!strcmp(name, "sync_release"))
+ return SYNC_RELEASE;
+ break;
+
default:
break;
}
mrp_resource_no_request = 0,
mrp_resource_release,
mrp_resource_acquire,
+ mrp_resource_pending_release,
};
mrp_attr_def_t *attrdefs,
mrp_resource_mgr_ftbl_t *manager,
void *manager_data);
+uint32_t mrp_resource_definition_create_with_sync_release(const char *name,
+ bool shareable,
+ bool sync_release,
+ mrp_attr_def_t *attrdefs,
+ mrp_resource_mgr_ftbl_t *manager,
+ void *manager_data);
void mrp_lua_resclass_create_from_c(uint32_t id);
#define RESPROTO_RESOURCE_STATE RESPROTO_TAG(7)
#define RESPROTO_RESOURCE_GRANT RESPROTO_TAG(8)
#define RESPROTO_RESOURCE_ADVICE RESPROTO_TAG(9)
-#define RESPROTO_RESOURCE_ID RESPROTO_TAG(10)
-#define RESPROTO_RESOURCE_NAME RESPROTO_TAG(11)
-#define RESPROTO_RESOURCE_FLAGS RESPROTO_TAG(12)
-#define RESPROTO_RESOURCE_PRIORITY RESPROTO_TAG(13)
-#define RESPROTO_CLASS_NAME RESPROTO_TAG(14)
-#define RESPROTO_ZONE_NAME RESPROTO_TAG(15)
-#define RESPROTO_ATTRIBUTE_INDEX RESPROTO_TAG(16)
-#define RESPROTO_ATTRIBUTE_NAME RESPROTO_TAG(17)
-#define RESPROTO_ATTRIBUTE_VALUE RESPROTO_TAG(18)
+#define RESPROTO_RESOURCE_PENDING RESPROTO_TAG(10)
+
+#define RESPROTO_RESOURCE_ID RESPROTO_TAG(11)
+#define RESPROTO_RESOURCE_NAME RESPROTO_TAG(12)
+#define RESPROTO_RESOURCE_FLAGS RESPROTO_TAG(13)
+#define RESPROTO_RESOURCE_PRIORITY RESPROTO_TAG(14)
+#define RESPROTO_CLASS_NAME RESPROTO_TAG(15)
+#define RESPROTO_ZONE_NAME RESPROTO_TAG(16)
+#define RESPROTO_ATTRIBUTE_INDEX RESPROTO_TAG(17)
+#define RESPROTO_ATTRIBUTE_NAME RESPROTO_TAG(18)
+#define RESPROTO_ATTRIBUTE_VALUE RESPROTO_TAG(19)
+#define RESPROTO_RESOURCE_SYNC_RELEASE RESPROTO_TAG(20)
typedef enum {
- RESPROTO_QUERY_RESOURCES,
+ RESPROTO_QUERY_RESOURCES, // 0
RESPROTO_QUERY_CLASSES,
RESPROTO_QUERY_ZONES,
RESPROTO_CREATE_RESOURCE_SET,
RESPROTO_DESTROY_RESOURCE_SET,
- RESPROTO_ACQUIRE_RESOURCE_SET,
+ RESPROTO_ACQUIRE_RESOURCE_SET, // 5
RESPROTO_RELEASE_RESOURCE_SET,
+ RESPROTO_DID_RELEASE_RESOURCE_SET,
RESPROTO_RESOURCES_EVENT,
} mrp_resproto_request_t;
static mqi_handle_t owner_tables[MRP_RESOURCE_MAX];
static mrp_resource_owner_t *get_owner(uint32_t, uint32_t);
+static void restore_owner(mrp_resource_owner_t *owner, mrp_resource_owner_t *oldowner);
static void reset_owners(uint32_t, mrp_resource_owner_t *);
static bool grant_ownership(mrp_resource_owner_t *, mrp_zone_t *,
mrp_application_class_t *, mrp_resource_set_t *,
mrp_resource_mask_t mask;
mrp_resource_mask_t mandatory;
mrp_resource_mask_t grant;
+ mrp_resource_mask_t old_grant;
mrp_resource_mask_t advice;
+ mrp_resource_mask_t pending_acquire = 0;
+ mrp_resource_mask_t pending_release = 0;
+ mrp_resource_state_t new_state;
void *clc, *rsc, *rc;
uint32_t rid;
uint32_t rcnt;
uint32_t replyid;
uint32_t nevent, maxev;
event_t *events, *ev, *lastev;
+ bool resource_granted_by_manager;
+ bool owned_by_other;
MRP_ASSERT(zoneid < MRP_ZONE_MAX, "invalid argument");
force_release = false;
mandatory = rset->resource.mask.mandatory;
grant = 0;
+ old_grant = rset->resource.mask.grant;
advice = 0;
+ pending_acquire = 0;
+ pending_release = 0;
rc = NULL;
+ if ((mrp_resource_pending_release == rset->state) && !rset->resource.mask.pending.release) {
+ // Release the resource that was pending to be released.
+
+ if (!rset->resource.mask.grant && rset->auto_release.current) {
+ rset->state = mrp_resource_release;
+ rset->auto_release.current = rset->auto_release.client;
+ }
+ else {
+ rset->state = mrp_resource_acquire;
+ }
+ }
+
switch (rset->state) {
case mrp_resource_acquire:
while ((res = mrp_resource_set_iterate_resources(rset, &rc))) {
+ resource_granted_by_manager = false;
+
rdef = res->def;
rid = rdef->id;
owner = get_owner(zoneid, rid);
+ mask = (mrp_resource_mask_t)1 << rid;
+
backup[rid] = *owner;
- if (grant_ownership(owner, zone, class, rset, res))
+ /*
+ * Here we first check if the resource is owned by some other client.
+ * If not - we will grant it as ordinary,
+ * otherwise - we will mark it as pending.
+ */
+ old = oldowners + rid;
+ owned_by_other = old->rset && old->rset != rset &&
+ ((old->rset->state == mrp_resource_acquire) ||
+ (old->rset->state == mrp_resource_pending_release && old->rset->resource.mask.pending.release));
+
+ resource_granted_by_manager = grant_ownership(owner, zone, class, rset, res);
+ if (resource_granted_by_manager)
grant |= ((mrp_resource_mask_t)1 << rid);
- else {
- if (owner->rset != rset)
- force_release |= owner->modal;
+ else if (owner->rset != rset) {
+ force_release |= owner->modal;
+ }
+
+
+ if (rdef->sync_release && (old_grant & mask) && !(grant & mask)) {
+ pending_release |= mask;
+ }
+
+ if (rdef->sync_release && (grant & mask) && owned_by_other) {
+ pending_acquire |= mask;
}
}
owners = get_owner(zoneid, 0);
+
+
if ((grant & mandatory) == mandatory &&
- mrp_resource_lua_veto(zone, rset, owners, grant, reqset))
- {
+ mrp_resource_lua_veto(zone, rset, owners, grant, reqset)) {
advice = grant;
}
else {
+
/* rollback, ie. restore the backed up state */
rc = NULL;
while ((res=mrp_resource_set_iterate_resources(rset,&rc))){
*owner = backup[rid];
if ((grant & mask)) {
- if ((ftbl = rdef->manager.ftbl) && ftbl->free)
+ if ((ftbl = rdef->manager.ftbl) && ftbl->free) {
ftbl->free(zone, res, rdef->manager.userdata);
+ }
}
if (advice_ownership(owner, zone, class, rset, res))
mrp_resource_lua_set_owners(zone, owners);
}
- break;
+ break; // mrp_resource_acquire
+
case mrp_resource_release:
while ((res = mrp_resource_set_iterate_resources(rset, &rc))) {
advice = 0;
break;
+ case mrp_resource_pending_release:
+ // Preserve the resource state while it is being freed by the client
+ grant = rset->resource.mask.grant;
+ pending_release = rset->resource.mask.pending.release;
+ pending_acquire = rset->resource.mask.pending.acquire;
+ break;
+
default:
break;
}
notify = 0;
replyid = (reqset == rset && reqid == rset->request.id) ? reqid:0;
+ new_state = rset->state;
if (force_release) {
move = (rset->state != mrp_resource_release);
notify = move ? MRP_RESOURCE_EVENT_RELEASE : 0;
changed = move || rset->resource.mask.grant;
- rset->state = mrp_resource_release;
rset->resource.mask.grant = 0;
+ new_state = mrp_resource_release;
+ }
+ else if (!pending_release && grant && pending_acquire && (mrp_resource_acquire == rset->state)) {
+ /* Resource is pending for acquisition.
+ * It will be actually granted when the current owner frees it.
+ * No event is emitted at this point. */
+ rset->resource.mask.grant = 0;
+ replyid = 0;
}
else {
if (grant == rset->resource.mask.grant) {
- if (rset->state == mrp_resource_acquire &&
- !grant && rset->dont_wait.current)
- {
- rset->state = mrp_resource_release;
- rset->dont_wait.current = rset->dont_wait.client;
+ if (rset->state == mrp_resource_acquire && !grant) {
+ if (pending_acquire != rset->resource.mask.pending.acquire && !pending_acquire) {
+ changed = true;
+ }
+ else if (rset->dont_wait.current) {
+ new_state = mrp_resource_pending_release;
+ rset->dont_wait.current = rset->dont_wait.client;
- notify = MRP_RESOURCE_EVENT_RELEASE;
- move = true;
+ notify = MRP_RESOURCE_EVENT_RELEASE;
+ }
}
}
else {
rset->resource.mask.grant = grant;
changed = true;
- if (rset->state != mrp_resource_release &&
- !grant && rset->auto_release.current)
- {
- rset->state = mrp_resource_release;
- rset->auto_release.current = rset->auto_release.client;
-
+ if (rset->state == mrp_resource_acquire && pending_release) {
notify = MRP_RESOURCE_EVENT_RELEASE;
- move = true;
+ new_state = mrp_resource_pending_release;
}
}
+
+ if (!grant && new_state == mrp_resource_acquire && rset->auto_release.current) {
+ new_state = mrp_resource_release;
+ rset->auto_release.current = rset->auto_release.client;
+ }
}
+ rset->state = new_state;
+
+ rset->resource.mask.pending.acquire = pending_acquire;
+ rset->resource.mask.pending.release = pending_release;
if (notify) {
mrp_resource_set_notify(rset, notify);
}
- if (advice != rset->resource.mask.advice) {
+ if (advice != rset->resource.mask.advice && !pending_release && !pending_acquire) {
rset->resource.mask.advice = advice;
changed = true;
}
} /* while rset */
} /* while class */
+ for (rid = 0; rid < rcnt; rid++) {
+ owner = get_owner(zoneid, rid);
+
+ if (owner->rset && owner->rset->resource.mask.pending.acquire) {
+ old = oldowners + rid;
+ restore_owner(owner, old);
+ }
+ }
+
manager_end_transaction(zone);
for (lastev = (ev = events) + nevent; ev < lastev; ev++) {
return resource_owners + (zone * MRP_RESOURCE_MAX + resid);
}
+static void restore_owner(mrp_resource_owner_t *owner, mrp_resource_owner_t *oldowner)
+{
+ memcpy(owner, oldowner, sizeof(mrp_resource_owner_t));
+}
+
static void reset_owners(uint32_t zone, mrp_resource_owner_t *oldowners)
{
mrp_resource_owner_t *owners = get_owner(zone, 0);
return rset->resource.mask.advice;
}
+mrp_resource_mask_t mrp_get_resource_set_pending_release(mrp_resource_set_t *rset)
+{
+ MRP_ASSERT(rset, "invalid argument");
+
+ return rset->resource.mask.pending.release;
+}
+
+mrp_resource_mask_t mrp_get_resource_set_pending_acquire(mrp_resource_set_t *rset)
+{
+ MRP_ASSERT(rset, "invalid argument");
+
+ return rset->resource.mask.pending.acquire;
+}
+
mrp_resource_client_t *mrp_get_resource_set_client(mrp_resource_set_t *rset)
{
MRP_ASSERT(rset, "invalid argument");
}
else {
rset->state = mrp_resource_release;
+ rset->resource.mask.pending.release = 0;
+ rset->resource.mask.pending.acquire = 0;
rset->request.id = reqid;
rset->request.stamp = get_request_stamp();
}
}
+void mrp_resource_set_did_release(mrp_resource_set_t *rset, uint32_t reqid)
+{
+ mqi_handle_t trh;
+
+ MRP_ASSERT(rset, "invalid argument");
+
+ mrp_debug("releasing resource set #%d", rset->id);
+
+ if (!rset->class.ptr)
+ rset->state = mrp_resource_release;
+ else {
+ rset->state = mrp_resource_pending_release;
+ rset->resource.mask.pending.release = 0;
+ rset->request.id = reqid;
+ rset->request.stamp = get_request_stamp();
+
+ mrp_application_class_move_resource_set(rset);
+
+ mrp_resource_set_notify(rset, MRP_RESOURCE_EVENT_RELEASE);
+
+ trh = mqi_begin_transaction();
+ mrp_resource_owner_update_zone(rset->zone, rset, reqid);
+ mqi_commit_transaction(trh);
+ }
+}
+
void mrp_resource_set_updated(mrp_resource_set_t *rset)
{
mrp_resource_t *res;
mrp_resource_mask_t mandatory;
mrp_resource_mask_t grant;
mrp_resource_mask_t advice;
+ struct {
+ mrp_resource_mask_t acquire;
+ mrp_resource_mask_t release;
+ } pending;
} mask;
mrp_list_hook_t list;
bool share;
static MRP_LIST_HOOK(manager_list);
static mqi_handle_t resource_user_table[RESOURCE_MAX];
-static uint32_t add_resource_definition(const char *, bool, uint32_t,
+static uint32_t add_resource_definition(const char *, bool, bool, uint32_t,
mrp_resource_mgr_ftbl_t *, void *);
#if 0
mrp_attr_def_t *attrdefs,
mrp_resource_mgr_ftbl_t *manager,
void *mgrdata)
+{
+ return mrp_resource_definition_create_with_sync_release(name, shareable,
+ false, attrdefs,
+ manager, mgrdata);
+}
+
+uint32_t mrp_resource_definition_create_with_sync_release(const char *name, bool shareable,
+ bool sync_release,
+ mrp_attr_def_t *attrdefs,
+ mrp_resource_mgr_ftbl_t *manager,
+ void *mgrdata)
{
uint32_t nattr;
uint32_t id;
for (nattr = 0; attrdefs && attrdefs[nattr].name; nattr++)
;
- id = add_resource_definition(name, shareable, nattr, manager, mgrdata);
+ id = add_resource_definition(name, shareable, sync_release, nattr, manager, mgrdata);
if (id != MRP_RESOURCE_ID_INVALID) {
def = mrp_resource_definition_find_by_id(id);
return retval;
}
+bool mrp_resource_definition_get_sync_release(uint32_t resid)
+{
+ bool result = false;
+
+ mrp_resource_def_t *rdef = mrp_resource_definition_find_by_id(resid);
+ if (rdef) {
+ result = rdef->sync_release;
+ }
+
+ return result;
+}
+
mrp_resource_t *mrp_resource_create(const char *name,
static uint32_t add_resource_definition(const char *name,
bool shareable,
+ bool sync_release,
uint32_t nattr,
mrp_resource_mgr_ftbl_t *mgrftbl,
void *mgrdata)
id = resource_def_count++;
- def->id = id;
- def->name = dup_name;
- def->shareable = shareable;
- def->nattr = nattr;
+ def->id = id;
+ def->name = dup_name;
+ def->shareable = shareable;
+ def->sync_release = sync_release;
+ def->nattr = nattr;
if (mgrftbl) {
def->manager.ftbl = mrp_alloc(sizeof(mrp_resource_mgr_ftbl_t));
uint32_t id;
const char *name;
bool shareable;
+ bool sync_release;
struct {
mrp_list_hook_t list;
mrp_resource_mgr_ftbl_t *ftbl;
projects / platform / upstream / murphy.git / commitdiff