Allow message pool management by platform code. (openthread#858)

* allow message pool management by platform code.

include/platform/Makefile.am

@@ -41,6 +41,7 @@ ot_platform_headers                      =\
     spi-slave.h                           \
     flash.h                               \
     settings.h                            \
+    messagepool.h                         \
     toolchain.h                           \
     $(NULL)
 

include/platform/messagepool.h

@@ -0,0 +1,101 @@
+/*
+ *  Copyright (c) 2016, The OpenThread Authors.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are met:
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of the copyright holder nor the
+ *     names of its contributors may be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file
+ * @brief
+ *   This file includes the platform abstraction for the message pool.
+ */
+
+#ifndef MESSAGEPOOL_H_
+#define MESSAGEPOOL_H_
+
+#include <stdint.h>
+#include <openthread-types.h>
+
+/**
+ * @defgroup messagepool MessagePool
+ * @ingroup platform
+ *
+ * @brief
+ *   This module includes the platform abstraction for the message pool.
+ *
+ * @{
+ *
+ */
+
+/**
+ * This structure contains a pointer to the next Message buffer.
+ *
+ */
+struct BufferHeader
+{
+    struct BufferHeader *mNext;  ///< A pointer to the next Message buffer.
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Initialize the platform implemented message pool with the provided buffer list.
+ *
+ * @param[in] aFreeBufferList   A linked list of free buffers.
+ * @param[in] aNumFreeBuffers   A pointer to an int containing the number of free buffers in aFreeBufferList.
+ * @param[in] aBufferSize       The size in bytes of a Buffer object.
+ *
+ */
+void otPlatMessagePoolInit(struct BufferHeader *aFreeBufferList, int *aNumFreeBuffers, size_t aBufferSize);
+
+/**
+ * Allocate a buffer from the platform managed buffer pool.
+ *
+ * @returns A pointer to the Buffer or NULL if no Buffers are available.
+ *
+ */
+struct BufferHeader *otPlatMessagePoolNew(void);
+
+/**
+ * This function is used to free a Buffer back to the platform managed buffer pool.
+ *
+ * @param[in]  aBuffer  The Buffer to free.
+ *
+ */
+void otPlatMessagePoolFree(struct BufferHeader *aBuffer);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+/**
+ * @}
+ *
+ */
+
+
+#endif  // MESSAGEPOOL_H_

src/core/common/message.cpp

@@ -56,6 +56,12 @@ MessagePool::MessagePool(void)
 
     mBuffers[kNumBuffers - 1].SetNextBuffer(NULL);
     mNumFreeBuffers = kNumBuffers;
+
+#if OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT
+    // Pass the list of free buffers and a pointer to the count of free buffers
+    // to the platform for management.
+    otPlatMessagePoolInit(static_cast<BufferHeader *>(mFreeBuffers), &mNumFreeBuffers, sizeof(Buffer));
+#endif
 }
 
 Message *MessagePool::New(uint8_t aType, uint16_t aReserved)
@@ -91,6 +97,16 @@ Buffer *MessagePool::NewBuffer(void)
 {
     Buffer *buffer = NULL;
 
+#if OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT
+    buffer = static_cast<Buffer *>(otPlatMessagePoolNew());
+
+    if (buffer == NULL)
+    {
+        otLogInfoMac("No available message buffer\n");
+    }
+
+#else // OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT
+
     if (mFreeBuffers == NULL)
     {
         otLogInfoMac("No available message buffer");
@@ -101,6 +117,7 @@ Buffer *MessagePool::NewBuffer(void)
     mFreeBuffers = mFreeBuffers->GetNextBuffer();
     buffer->SetNextBuffer(NULL);
     mNumFreeBuffers--;
+#endif // OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT
 
 exit:
     return buffer;
@@ -113,9 +130,13 @@ ThreadError MessagePool::FreeBuffers(Buffer *aBuffer)
     while (aBuffer != NULL)
     {
         tmpBuffer = aBuffer->GetNextBuffer();
+#if OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT
+        otPlatMessagePoolFree(static_cast<struct BufferHeader *>(aBuffer));
+#else // OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT
         aBuffer->SetNextBuffer(mFreeBuffers);
         mFreeBuffers = aBuffer;
         mNumFreeBuffers++;
+#endif // OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT
         aBuffer = tmpBuffer;
     }
 

src/core/common/message.hpp

@@ -43,10 +43,11 @@
 #include <stdint.h>
 #include <string.h>
 
-#include <openthread-types.h>
 #include <openthread-core-config.h>
+#include <openthread-types.h>
 #include <common/code_utils.hpp>
 #include <mac/mac_frame.hpp>
+#include <platform/messagepool.h>
 
 namespace Thread {
 
@@ -90,14 +91,7 @@ struct MessageListEntry
     Message            *mPrev;  ///< A pointer to the previous Message in the list.
 };
 
-/**
- * This structure contains a pointer to the next Message buffer.
- *
- */
-struct BufferHeader
-{
-    class Buffer *mNext;  ///< A pointer to the next Message buffer.
-};
+
 
 /**
  * This structure contains metdata about a Message.
@@ -136,7 +130,7 @@ struct MessageInfo
  * This class represents a Message buffer.
  *
  */
-class Buffer
+class Buffer : public ::BufferHeader
 {
     friend class Message;
 
@@ -147,13 +141,13 @@ class Buffer
      * @returns A pointer to the next message buffer.
      *
      */
-    class Buffer *GetNextBuffer(void) const { return mHeader.mNext; }
+    class Buffer *GetNextBuffer(void) const { return static_cast<Buffer *>(mNext); }
 
     /**
      * This method sets the pointer to the next message buffer.
      *
      */
-    void SetNextBuffer(class Buffer *buf) { mHeader.mNext = buf; }
+    void SetNextBuffer(class Buffer *buf) { mNext = static_cast<BufferHeader *>(buf); }
 
 private:
     /**
@@ -194,7 +188,6 @@ class Buffer
         kHeadBufferDataSize = kBufferDataSize - sizeof(struct MessageInfo),
     };
 
-    struct BufferHeader mHeader;
     union
     {
         struct

src/core/openthread-core-default-config.h

@@ -247,6 +247,19 @@
 #define OPENTHREAD_CONFIG_JOIN_BEACON_VERSION                   kProtocolVersion
 #endif  // OPENTHREAD_CONFIG_JOIN_BEACON_VERSION
 
+/**
+ * @def OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT
+ *
+ * The message pool is managed by platform defined logic when this flag is set.
+ * This feature would typically be used when operating in a multi-threaded system
+ * and multiple threads need to access the message pool.
+ *
+ */
+#ifndef OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT
+#define OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT           0
+#endif  // OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT
+
+
 /**
  * @def OPENTHREAD_CONFIG_LOG_LEVEL
  *