LwM2M Callback Reentrancy

[ibiglari]

Hi,

A few questions regarding LwM2M engine I haven't been able to find the answers to in documentation:

• Do callbacks registered for LwM2M by calling lwm2m_engine_register_validate_callback() or lwm2m_engine_register_post_write_callback() need to be reentrant safe, or does the LwM2M engine take care of not calling the same callback until previous invocation has returned?
• If the server writes multiple values to the same path (same object, instance and resource ID), does the write callback get fired for all the values, or does the engine only call the callback with the most recent value?
• If the engine calls the callback for each write operation, does it mean the engine will manage the buffer for all the write operations? For instance, if the LwM2M server writes 128 bytes of data to /1234/0/0, 10 times in a row, does the LwM2M engine consume up to one kilobyte of memory while calling the callback for each write operation?

Kind Regards,
Iman

[Øyvind]

Hello Imam, 

I will need to forward your questions to our LwM2M team. 

From zephyr\include\zephyr\net\lwm2m.h it states

/**
 * @brief Asynchronous callback when data has been set to a resource buffer.
 *
 * After changing the data of a resource buffer, the LwM2M engine can
 * make use of this callback to pass the data back to the client or LwM2M
 * objects.
 *
 * A function of this type can be registered via:
 * lwm2m_engine_register_validate_callback()
 * lwm2m_engine_register_post_write_callback()
 *
 * @param[in] obj_inst_id Object instance ID generating the callback.
 * @param[in] res_id Resource ID generating the callback.
 * @param[in] res_inst_id Resource instance ID generating the callback
 *                        (typically 0 for non-multi instance resources).
 * @param[in] data Pointer to data.
 * @param[in] data_len Length of the data.
 * @param[in] last_block Flag used during block transfer to indicate the last
 *                       block of data. For non-block transfers this is always
 *                       false.
 * @param[in] total_size Expected total size of data for a block transfer.
 *                       For non-block transfers this is 0.
 *
 * @return Callback returns a negative error code (errno.h) indicating
 *         reason of failure or 0 for success.
 */
typedef int (*lwm2m_engine_set_data_cb_t)(uint16_t obj_inst_id,
					  uint16_t res_id, uint16_t res_inst_id,
					  uint8_t *data, uint16_t data_len,
					  bool last_block, size_t total_size);

/**
 * @brief Set resource (instance) validation callback
 *
 * This callback is triggered before setting the value of a resource to the
 * resource data buffer.
 *
 * The callback allows an LwM2M client or object to validate the data before
 * writing and notify an error if the data should be discarded for any reason
 * (by returning a negative error code).
 *
 * @note All resources that have a validation callback registered are initially
 *       decoded into a temporary validation buffer. Make sure that
 *       ``CONFIG_LWM2M_ENGINE_VALIDATION_BUFFER_SIZE`` is large enough to
 *       store each of the validated resources (individually).
 *
 * @param[in] pathstr LwM2M path string "obj/obj-inst/res(/res-inst)"
 * @param[in] cb Validate resource data callback
 *
 * @return 0 for success or negative in case of error.
 */
int lwm2m_engine_register_validate_callback(const char *pathstr,
					    lwm2m_engine_set_data_cb_t cb);

 /**
 * @brief Set resource (instance) post-write callback
 *
 * This callback is triggered after setting the value of a resource to the
 * resource data buffer.
 *
 * It allows an LwM2M client or object to post-process the value of a resource
 * or trigger other related resource calculations.
 *
 * @param[in] pathstr LwM2M path string "obj/obj-inst/res(/res-inst)"
 * @param[in] cb Post-write resource callback
 *
 * @return 0 for success or negative in case of error.
 */
int lwm2m_engine_register_post_write_callback(const char *pathstr,
					      lwm2m_engine_set_data_cb_t cb);

From zephyr\subsys\net\lib\lwm2m\Kconfig

config LWM2M_ENGINE_VALIDATION_BUFFER_SIZE
	int "Size of the validation buffer for the incoming data"
	default 64
	help
	  LwM2M will use the validation buffer during the write operation, to
	  decode the resource value before validating it (applies for resources
	  for which validation callback has been registered). Set this value to
	  the maximum expected size of the resources that need to be validated
	  (and thus have validation callback registered).
	  Setting the validation buffer size to 0 disables validation support.

From zephyr\subsys\net\lib\lwm2m\lwm2m_registry.c

int lwm2m_engine_register_validate_callback(const char *pathstr, lwm2m_engine_set_data_cb_t cb)
{
#if CONFIG_LWM2M_ENGINE_VALIDATION_BUFFER_SIZE > 0
	int ret;
	struct lwm2m_engine_res *res = NULL;

	ret = lwm2m_engine_get_resource(pathstr, &res);
	if (ret < 0) {
		return ret;
	}

	res->validate_cb = cb;
	return 0;
#else
	ARG_UNUSED(pathstr);
	ARG_UNUSED(cb);

	LOG_ERR("Validation disabled. Set "
		"CONFIG_LWM2M_ENGINE_VALIDATION_BUFFER_SIZE > 0 to "
		"enable validation support.");
	return -ENOTSUP;
#endif /* CONFIG_LWM2M_ENGINE_VALIDATION_BUFFER_SIZE > 0 */
}

int lwm2m_engine_register_post_write_callback(const char *pathstr, lwm2m_engine_set_data_cb_t cb)
{
	int ret;
	struct lwm2m_engine_res *res = NULL;

	ret = lwm2m_engine_get_resource(pathstr, &res);
	if (ret < 0) {
		return ret;
	}

	res->post_write_cb = cb;
	return 0;
}

Kind regards,
Øyvind

[ibiglari]

Hi,

Thanks for your reply.

Øyvind said:

I will need to forward your questions to our LwM2M team. 

That would be great!

Kind Regards,
Iman

[Øyvind]

Hello, 

Our LwM2M team has provided the following answers:

Do callbacks registered for LwM2M by calling lwm2m_engine_register_validate_callback() or lwm2m_engine_register_post_write_callback() need to be reentrant safe, or does the LwM2M engine take care of not calling the same callback until previous invocation has returned?

Callbacks from LwM2M engine are coming from its thread context while processing the data. So callback effectively blocks the LwM2M engine until it returns. Therefore simultaneous callbacks cannot happen at a same time.

If the server writes multiple values to the same path (same object, instance and resource ID), does the write callback get fired for all the values, or does the engine only call the callback with the most recent value?

Callback happens every time the value changes in the LwM2M resource buffer. So if a message contains multiple values for one resource, it causes multiple callbacks. Callbacks are executed while parsing the message.

If the engine calls the callback for each write operation, does it mean the engine will manage the buffer for all the write operations? For instance, if the LwM2M server writes 128 bytes of data to /1234/0/0, 10 times in a row, does the LwM2M engine consume up to one kilobyte of memory while calling the callback for each write operation?

Each resource has only one buffer. Pointers in the callback are pointing the same buffer space that is set for the resource, these are not temporary buffers. Buffers are set up by the object, or can be overwritten by an application using lwm2m_engine_set_res_buf().

Kind regards,
Øyvind