/*! * \brief This function removes an endpoint. * * Removes an endpoint with specified structure / params (core, node and port). * * \param[in] endpoint Pointer to the endpoint structure. * * \return MCC_SUCCESS * \return MCC_ERR_ENDPOINT (invalid value for port or the endpoint doesn't exist) */ int mcc_remove_endpoint(MCC_ENDPOINT endpoint) { int i=0; /* must be valid */ if(endpoint.port == MCC_RESERVED_PORT_NUMBER) return MCC_ERR_ENDPOINT; MCC_DCACHE_INVALIDATE_MLINES(&bookeeping_data->endpoint_table[0], MCC_ATTR_MAX_RECEIVE_ENDPOINTS * sizeof(MCC_ENDPOINT_MAP_ITEM)); for(i = 0; i < MCC_ATTR_MAX_RECEIVE_ENDPOINTS; i++) { if(MCC_ENDPOINTS_EQUAL(bookeeping_data->endpoint_table[i].endpoint, endpoint)) { /* clear the queue */ MCC_RECEIVE_BUFFER * buffer = mcc_dequeue_buffer((MCC_RECEIVE_LIST *)&bookeeping_data->endpoint_table[i].list); while(buffer) { mcc_queue_buffer(&bookeeping_data->free_list, buffer); buffer = mcc_dequeue_buffer((MCC_RECEIVE_LIST *)&bookeeping_data->endpoint_table[i].list); } /* indicate free */ bookeeping_data->endpoint_table[i].endpoint.port = MCC_RESERVED_PORT_NUMBER; MCC_DCACHE_FLUSH_MLINES((void*)&bookeeping_data->endpoint_table[i].endpoint.port, sizeof(MCC_PORT)); return MCC_SUCCESS; } } return MCC_ERR_ENDPOINT; }
/*! * \brief This function receives a message from the specified endpoint if one is available. The data is NOT copied into the user-app. buffer. * * This is the "zero-copy receive" version of the MCC receive function. No data is copied. * Only the pointer to the data is returned. This version is fast, but it requires the user to manage * buffer allocation. Specifically, the user must decide when a buffer is no longer in use and * make the appropriate API call to free it, see mcc_free_buffer. * * \param[out] src_endpoint Pointer to the MCC_ENDPOINT structure to be filled by the endpoint identifying the message sender. * \param[in] dest_endpoint Pointer to the local receiving endpoint to receive from. * \param[out] buffer_p Pointer to the MCC buffer of the shared memory where the received data is stored. * \param[out] recv_size Pointer to an MCC_MEM_SIZE that will contain the number of valid bytes in the buffer. * \param[in] timeout_ms Timeout, in milliseconds, to wait for a free buffer. A value of 0 means don't wait (non-blocking call). A value of 0xffffffff means wait forever (blocking call). * * \return MCC_SUCCESS * \return MCC_ERR_ENDPOINT (the endpoint does not exist) * \return MCC_ERR_SEMAPHORE (semaphore handling error) * \return MCC_ERR_TIMEOUT (timeout exceeded before a new message came) * * \see mcc_send * \see mcc_recv * \see MCC_ENDPOINT */ int mcc_recv_nocopy(MCC_ENDPOINT *src_endpoint, MCC_ENDPOINT *dest_endpoint, void **buffer_p, MCC_MEM_SIZE *recv_size, unsigned int timeout_ms) { MCC_RECEIVE_LIST *list = null; int return_value; return_value = mcc_recv_common_part(dest_endpoint, timeout_ms, (MCC_RECEIVE_LIST**)&list); if(return_value != MCC_SUCCESS) return return_value; /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; MCC_DCACHE_INVALIDATE_MLINES((void*)list, sizeof(MCC_RECEIVE_LIST*)); if(list->head == (MCC_RECEIVE_BUFFER*)0) { /* Buffer not dequeued before the timeout */ mcc_release_semaphore(); return MCC_ERR_TIMEOUT; } /* Get the message pointer from the head of the receive buffer list */ MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->data, list->head->data_len); *buffer_p = (void*)&list->head->data; MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->source, sizeof(MCC_ENDPOINT) + sizeof(MCC_MEM_SIZE)); mcc_memcpy((void*)&list->head->source, (void*)src_endpoint, sizeof(MCC_ENDPOINT)); *recv_size = (MCC_MEM_SIZE)(list->head->data_len); /* Dequeue the buffer from the endpoint list */ mcc_dequeue_buffer(list); /* Semaphore-protected section end */ return_value = mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; return return_value; }
/*! * \private * * \brief This function dequeues a buffer from the free list. * * This is an internal implementation of the mcc_get_buffer() function. It is called * either from the mcc_send() or from mcc_get_buffer() when the non-copy-send * mechanism is enabled by the MCC_SEND_RECV_NOCOPY_API_ENABLED macro in mcc_config.h. * * \param[out] buffer Pointer to the MCC buffer dequeued from the free list. * \param[out] buf_size Pointer to an MCC_MEM_SIZE that is used for passing the size of the dequeued MCC buffer to the application. * \param[in] timeout_ms Timeout, in milliseconds, to wait for a free buffer. A value of 0 means don't wait (non-blocking call). A value of 0xffffffff means wait forever (blocking call). * * \return MCC_SUCCESS * \return MCC_ERR_SEMAPHORE (semaphore handling error) * \return MCC_ERR_TIMEOUT (timeout exceeded before a buffer became available) * \return MCC_ERR_NOMEM (no free buffer available and timeout_ms set to 0) * * \see mcc_send_nocopy * \see mcc_send * \see mcc_get_buffer */ static int mcc_get_buffer_internal(void **buffer, MCC_MEM_SIZE *buf_size, unsigned int timeout_ms) { int return_value; MCC_RECEIVE_BUFFER * buf = null; *buffer = null; /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Dequeue the buffer from the free list */ MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); buf = mcc_dequeue_buffer(&bookeeping_data->free_list); /* Semaphore-protected section end */ mcc_release_semaphore(); if(buf == null) { /* Non-blocking call */ if(timeout_ms == 0) { return MCC_ERR_NOMEM; } else { /* Wait for the buffer freed event */ return_value = mcc_wait_for_buffer_freed((MCC_RECEIVE_BUFFER **)&buf, timeout_ms); if(MCC_SUCCESS != return_value) { return return_value; } } } /* Return the MCC buffer size and the pointer to the dequeued MCC buffer */ *buf_size = (MCC_MEM_SIZE)sizeof(bookeeping_data->r_buffers[0].data); *buffer = (void*)buf->data; return MCC_SUCCESS; }
/*! * \brief This function receives a message from the specified endpoint if one is available. The data is NOT copied into the user-app. buffer. * * This is the "zero-copy receive" version of the MCC receive function. No data is copied. * Only the pointer to the data is returned. This version is fast, but it requires the user to manage * buffer allocation. Specifically, the user must decide when a buffer is no longer in use and * make the appropriate API call to free it. * * \param[in] endpoint Pointer to the receiving endpoint to receive from. * \param[out] buffer_p Pointer to the MCC buffer of the shared memory where the received data is stored. * \param[out] recv_size Pointer to an MCC_MEM_SIZE that will contain the number of valid bytes in the buffer. * \param[in] timeout_us Timeout, in microseconds, to wait for a free buffer. A value of 0 means don't wait (non-blocking call). A value of 0xffffffff means wait forever (blocking call). * * \return MCC_SUCCESS * \return MCC_ERR_ENDPOINT (the endpoint does not exist) * \return MCC_ERR_SEMAPHORE (semaphore handling error) * \return MCC_ERR_TIMEOUT (timeout exceeded before a new message came) * * \see mcc_send * \see mcc_recv_copy * \see MCC_ENDPOINT */ int mcc_recv_nocopy(MCC_ENDPOINT *endpoint, void **buffer_p, MCC_MEM_SIZE *recv_size, unsigned int timeout_us) { MCC_RECEIVE_LIST *list; int return_value; #if (MCC_OS_USED == MCC_MQX) unsigned int time_us_tmp; unsigned int lwevent_index = endpoint->port / MCC_MQX_LWEVENT_GROUP_SIZE; unsigned int lwevent_group_index = endpoint->port % MCC_MQX_LWEVENT_GROUP_SIZE; MQX_TICK_STRUCT tick_time; #endif /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Get list of buffers kept by the particular endpoint */ list = mcc_get_endpoint_list(*endpoint); /* Semaphore-protected section end */ return_value = mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* The endpoint is not valid */ if(list == null) { return MCC_ERR_ENDPOINT; } if(list->head == (MCC_RECEIVE_BUFFER*)0) { /* Non-blocking call */ if(timeout_us == 0) { return MCC_ERR_TIMEOUT; } /* Blocking call */ else { #if (MCC_OS_USED == MCC_MQX) if(timeout_us == 0xFFFFFFFF) { _lwevent_wait_ticks(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index, TRUE, 0); } /* timeout_us > 0 */ else { _time_get_ticks(&tick_time); _time_add_usec_to_ticks(&tick_time, timeout_us); _lwevent_wait_until(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index, TRUE, &tick_time); } #endif MCC_DCACHE_INVALIDATE_MLINES((void*)list, sizeof(MCC_RECEIVE_LIST*)); } } /* Clear event bit specified for the particular endpoint in the lwevent_buffer_queued lwevent group */ _lwevent_clear(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index); if(list->head == (MCC_RECEIVE_BUFFER*)0) { /* Buffer not dequeued before the timeout */ return MCC_ERR_TIMEOUT; } /* Get the message pointer from the head of the receive buffer list */ MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->data, list->head->data_len); *buffer_p = (void*)&list->head->data; MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->data_len, sizeof(MCC_MEM_SIZE)); *recv_size = (MCC_MEM_SIZE)(list->head->data_len); /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Dequeue the buffer from the endpoint list */ mcc_dequeue_buffer(list); /* Semaphore-protected section end */ return_value = mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; return return_value; }
/*! * \brief This function receives a message from the specified endpoint if one is available. * The data will be copied from the receive buffer into the user supplied buffer. * * This is the "receive with copy" version of the MCC receive function. This version is simple * to use but it requires copying data from shared memory into the user space buffer. * The user has no obligation or burden to manage the shared memory buffers. * * \param[in] endpoint Pointer to the receiving endpoint to receive from. * \param[in] buffer Pointer to the user-app. buffer where data will be copied into. * \param[in] buffer_size The maximum number of bytes to copy. * \param[out] recv_size Pointer to an MCC_MEM_SIZE that will contain the number of bytes actually copied into the buffer. * \param[in] timeout_us Timeout, in microseconds, to wait for a free buffer. A value of 0 means don't wait (non-blocking call). A value of 0xffffffff means wait forever (blocking call). * * \return MCC_SUCCESS * \return MCC_ERR_ENDPOINT (the endpoint does not exist) * \return MCC_ERR_SEMAPHORE (semaphore handling error) * \return MCC_ERR_TIMEOUT (timeout exceeded before a new message came) * * \see mcc_send * \see mcc_recv_nocopy * \see MCC_ENDPOINT */ int mcc_recv_copy(MCC_ENDPOINT *endpoint, void *buffer, MCC_MEM_SIZE buffer_size, MCC_MEM_SIZE *recv_size, unsigned int timeout_us) { MCC_RECEIVE_LIST *list; MCC_RECEIVE_BUFFER * buf; MCC_SIGNAL affiliated_signal; MCC_ENDPOINT tmp_destination = {(MCC_CORE)0, (MCC_NODE)0, (MCC_PORT)0}; int return_value, i = 0; #if (MCC_OS_USED == MCC_MQX) unsigned int time_us_tmp; unsigned int lwevent_index = endpoint->port / MCC_MQX_LWEVENT_GROUP_SIZE; unsigned int lwevent_group_index = endpoint->port % MCC_MQX_LWEVENT_GROUP_SIZE; MQX_TICK_STRUCT tick_time; #endif /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Get list of buffers kept by the particular endpoint */ list = mcc_get_endpoint_list(*endpoint); /* Semaphore-protected section end */ return_value = mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* The endpoint is not valid */ if(list == null) { return MCC_ERR_ENDPOINT; } if(list->head == (MCC_RECEIVE_BUFFER*)0) { /* Non-blocking call */ if(timeout_us == 0) { return MCC_ERR_TIMEOUT; } /* Blocking call */ else { #if (MCC_OS_USED == MCC_MQX) if(timeout_us == 0xFFFFFFFF) { _lwevent_wait_ticks(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index, TRUE, 0); } /* timeout_us > 0 */ else { _time_get_ticks(&tick_time); _time_add_usec_to_ticks(&tick_time, timeout_us); _lwevent_wait_until(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index, TRUE, &tick_time); } #endif MCC_DCACHE_INVALIDATE_MLINES((void*)list, sizeof(MCC_RECEIVE_LIST*)); } } /* Clear event bit specified for the particular endpoint in the lwevent_buffer_queued lwevent group */ _lwevent_clear(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index); if(list->head == (MCC_RECEIVE_BUFFER*)0) { /* Buffer not dequeued before the timeout */ return MCC_ERR_TIMEOUT; } /* Copy the message from the MCC receive buffer into the user-app. buffer */ MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->data_len, sizeof(MCC_MEM_SIZE)); if (list->head->data_len > buffer_size) { list->head->data_len = buffer_size; } *recv_size = (MCC_MEM_SIZE)(list->head->data_len); MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->data, list->head->data_len); mcc_memcpy((void*)list->head->data, buffer, list->head->data_len); /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Dequeue the buffer from the endpoint list */ buf = mcc_dequeue_buffer(list); /* Enqueue the buffer into the free list */ MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); mcc_queue_buffer(&bookeeping_data->free_list, buf); /* Notify all cores (except of itself) via CPU-to-CPU interrupt that a buffer has been freed */ affiliated_signal.type = BUFFER_FREED; affiliated_signal.destination = tmp_destination; for (i=0; i<MCC_NUM_CORES; i++) { if(i != MCC_CORE_NUMBER) { mcc_queue_signal(i, affiliated_signal); } } mcc_generate_cpu_to_cpu_interrupt(); /* Semaphore-protected section end */ return_value = mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; return return_value; }
/*! * \brief This function sends a message to an endpoint. * * The message is copied into the MCC buffer and the destination core is signaled. * * \param[in] endpoint Pointer to the receiving endpoint to send to. * \param[in] msg Pointer to the message to be sent. * \param[in] msg_size Size of the message to be sent in bytes. * \param[in] timeout_us Timeout, in microseconds, to wait for a free buffer. A value of 0 means don't wait (non-blocking call). A value of 0xffffffff means wait forever (blocking call). * * \return MCC_SUCCESS * \return MCC_ERR_ENDPOINT (the endpoint does not exist) * \return MCC_ERR_SEMAPHORE (semaphore handling error) * \return MCC_ERR_INVAL (the msg_size exceeds the size of a data buffer) * \return MCC_ERR_TIMEOUT (timeout exceeded before a buffer became available) * \return MCC_ERR_NOMEM (no free buffer available and timeout_us set to 0) * \return MCC_ERR_SQ_FULL (signal queue is full) * * \see mcc_recv_copy * \see mcc_recv_nocopy * \see MCC_ENDPOINT */ int mcc_send(MCC_ENDPOINT *endpoint, void *msg, MCC_MEM_SIZE msg_size, unsigned int timeout_us) { int return_value, end_time_set_flag = 0; MCC_RECEIVE_LIST *list; MCC_RECEIVE_BUFFER * buf; MCC_SIGNAL affiliated_signal; #if (MCC_OS_USED == MCC_MQX) unsigned int time_us_tmp; MQX_TICK_STRUCT tick_time; #endif /* Check if the size of the message to be sent does not exceed the size of the mcc buffer */ if(msg_size > sizeof(bookeeping_data->r_buffers[0].data)) { return MCC_ERR_INVAL; } /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Dequeue the buffer from the free list */ MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); buf = mcc_dequeue_buffer(&bookeeping_data->free_list); while(buf == null) { mcc_release_semaphore(); /* Non-blocking call */ if(timeout_us == 0) { return MCC_ERR_NOMEM; } /* Blocking calls: CPU-to-CPU ISR sets the event and thus resumes tasks waiting for a free MCC buffer. * As the interrupt request is send to all cores when a buffer is freed it could happen that several * tasks from different cores/nodes are waiting for a free buffer and all of them are notified that the buffer * has been freed. This function has to check (after the wake up) that a buffer is really available and has not been already * grabbed by another "competitor task" that has been faster. If so, it has to wait again for the next notification. */ /* wait forever */ else if(timeout_us == 0xFFFFFFFF) { #if (MCC_OS_USED == MCC_MQX) _lwevent_wait_ticks(&lwevent_buffer_freed, 1, TRUE, 0); _lwevent_clear(&lwevent_buffer_freed, 1); #endif } /* timeout_us > 0 */ else { #if (MCC_OS_USED == MCC_MQX) if(!end_time_set_flag) { _time_get_ticks(&tick_time); _time_add_usec_to_ticks(&tick_time, timeout_us); end_time_set_flag = 1; } return_value = _lwevent_wait_until(&lwevent_buffer_freed, 1, TRUE, &tick_time); if(return_value == LWEVENT_WAIT_TIMEOUT) { /* Buffer not dequeued before the timeout */ return MCC_ERR_TIMEOUT; } _lwevent_clear(&lwevent_buffer_freed, 1); #endif } MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); mcc_get_semaphore(); buf = mcc_dequeue_buffer(&bookeeping_data->free_list); } /* Semaphore-protected section end */ mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Copy the message into the MCC receive buffer */ mcc_memcpy(msg, (void*)buf->data, (unsigned int)msg_size); MCC_DCACHE_FLUSH_MLINES((void*)buf->data, msg_size); buf->data_len = msg_size; MCC_DCACHE_FLUSH_MLINES((void*)&buf->data_len, sizeof(MCC_MEM_SIZE)); /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Get list of buffers kept by the particular endpoint */ list = mcc_get_endpoint_list(*endpoint); if(list == null) { /* The endpoint does not exists (has not been registered so far), free the buffer and return immediately - error */ /* Enqueue the buffer back into the free list */ MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); mcc_queue_buffer(&bookeeping_data->free_list, buf); mcc_release_semaphore(); return MCC_ERR_ENDPOINT; } /* Write the signal type into the signal queue of the particular core */ affiliated_signal.type = BUFFER_QUEUED; affiliated_signal.destination = *endpoint; return_value = mcc_queue_signal(endpoint->core, affiliated_signal); if(return_value != MCC_SUCCESS) { /* Signal queue is full, free the buffer and return immediately - error */ MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); mcc_queue_buffer(&bookeeping_data->free_list, buf); mcc_release_semaphore(); return return_value; } /* Enqueue the buffer into the endpoint buffer list */ mcc_queue_buffer(list, buf); /* Semaphore-protected section end */ mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Signal the other core by generating the CPU-to-CPU interrupt */ return_value = mcc_generate_cpu_to_cpu_interrupt(); return return_value; }
/*! * \brief This function receives a message from the specified endpoint if one is available. * The data is copied from the receive buffer into the user supplied buffer. * * This is the "receive with copy" version of the MCC receive function. This version is simple * to use but it requires copying data from shared memory into the user space buffer. * The user has no obligation or burden to manage the shared memory buffers. * * \param[out] src_endpoint Pointer to the MCC_ENDPOINT structure to be filled by the endpoint identifying the message sender. * \param[in] dest_endpoint Pointer to the local receiving endpoint to receive from. * \param[in] buffer Pointer to the user-app. buffer where data will be copied into. * \param[in] buffer_size The maximum number of bytes to copy. * \param[out] recv_size Pointer to an MCC_MEM_SIZE that will contain the number of bytes actually copied into the buffer. * \param[in] timeout_ms Timeout, in milliseconds, to wait for a free buffer. A value of 0 means don't wait (non-blocking call). A value of 0xffffffff means wait forever (blocking call). * * \return MCC_SUCCESS * \return MCC_ERR_ENDPOINT (the endpoint does not exist) * \return MCC_ERR_SEMAPHORE (semaphore handling error) * \return MCC_ERR_TIMEOUT (timeout exceeded before a new message came) * * \see mcc_send * \see mcc_recv_nocopy * \see MCC_ENDPOINT */ int mcc_recv(MCC_ENDPOINT *src_endpoint, MCC_ENDPOINT *dest_endpoint, void *buffer, MCC_MEM_SIZE buffer_size, MCC_MEM_SIZE *recv_size, unsigned int timeout_ms) { MCC_RECEIVE_LIST *list = null; MCC_RECEIVE_BUFFER * buf; MCC_SIGNAL affiliated_signal; MCC_ENDPOINT tmp_destination = {(MCC_CORE)0, (MCC_NODE)0, (MCC_PORT)0}; int return_value, i = 0; return_value = mcc_recv_common_part(dest_endpoint, timeout_ms, (MCC_RECEIVE_LIST**)&list); if(return_value != MCC_SUCCESS) return return_value; /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; MCC_DCACHE_INVALIDATE_MLINES((void*)list, sizeof(MCC_RECEIVE_LIST*)); if(list->head == (MCC_RECEIVE_BUFFER*)0) { /* Buffer not dequeued before the timeout */ mcc_release_semaphore(); return MCC_ERR_TIMEOUT; } /* Copy the message from the MCC receive buffer into the user-app. buffer */ MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->source, sizeof(MCC_ENDPOINT) + sizeof(MCC_MEM_SIZE)); mcc_memcpy((void*)&list->head->source, (void*)src_endpoint, sizeof(MCC_ENDPOINT)); if (list->head->data_len > buffer_size) { list->head->data_len = buffer_size; } *recv_size = (MCC_MEM_SIZE)(list->head->data_len); MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->data, list->head->data_len); mcc_memcpy((void*)list->head->data, buffer, list->head->data_len); /* Dequeue the buffer from the endpoint list */ list->head = (MCC_RECEIVE_BUFFER*)MCC_MEM_VIRT_TO_PHYS(list->head); buf = mcc_dequeue_buffer(list); /* Enqueue the buffer into the free list */ MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); mcc_queue_buffer(&bookeeping_data->free_list, buf); /* Notify all cores (except of itself) via CPU-to-CPU interrupt that a buffer has been freed */ affiliated_signal.type = BUFFER_FREED; affiliated_signal.destination = tmp_destination; for (i=0; i<MCC_NUM_CORES; i++) { if(i != MCC_CORE_NUMBER) { mcc_queue_signal(i, affiliated_signal); } } /* Semaphore-protected section end */ return_value = mcc_release_semaphore(); mcc_generate_cpu_to_cpu_interrupt(); if(return_value != MCC_SUCCESS) return return_value; return return_value; }