This is an automated email from the ASF dual-hosted git repository.

xiaoxiang781216 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx.git


The following commit(s) were added to refs/heads/master by this push:
     new d9b891b2bea drivers/rpmsg: use the nuttx list, container_of and syslog
d9b891b2bea is described below

commit d9b891b2bea3cd6ad0738398f3b0a0f403ec3e1c
Author: yintao <[email protected]>
AuthorDate: Thu Nov 12 12:52:22 2026 +0800

    drivers/rpmsg: use the nuttx list, container_of and syslog
    
    The rpmsg framework keeps its own device, callback and bind lists, and
    the transports print their dumps, through the libmetal wrappers. These
    are NuttX drivers: use list_node, container_of() and syslog() instead.
    
    The lists that belong to open-amp (rdev->endpoints) and the rdev->lock
    mutex stay on the libmetal API.
    
    Signed-off-by: yintao <[email protected]>
    Signed-off-by: Bowen Wang <[email protected]>
---
 drivers/rpmsg/rpmsg.c             | 121 ++++++++++++++++----------------------
 drivers/rpmsg/rpmsg.h             |   5 +-
 drivers/rpmsg/rpmsg_port.c        |  58 ++++++++----------
 drivers/rpmsg/rpmsg_router_edge.c |   3 +-
 drivers/rpmsg/rpmsg_virtio.c      |  64 +++++++++-----------
 5 files changed, 109 insertions(+), 142 deletions(-)

diff --git a/drivers/rpmsg/rpmsg.c b/drivers/rpmsg/rpmsg.c
index 71e5d8ada4e..d0e3f0c79c2 100644
--- a/drivers/rpmsg/rpmsg.c
+++ b/drivers/rpmsg/rpmsg.c
@@ -28,10 +28,13 @@
 
 #include <inttypes.h>
 #include <limits.h>
+#include <syslog.h>
 
 #include <metal/sys.h>
 #include <nuttx/kmalloc.h>
+#include <nuttx/list.h>
 #include <nuttx/mutex.h>
+#include <nuttx/nuttx.h>
 #include <nuttx/rwsem.h>
 #include <nuttx/semaphore.h>
 
@@ -49,7 +52,7 @@ struct rpmsg_bind_s
 {
   char              name[RPMSG_NAME_SIZE];
   uint32_t          dest;
-  struct metal_list node;
+  struct list_node  node;
 };
 
 struct rpmsg_cb_s
@@ -59,7 +62,7 @@ struct rpmsg_cb_s
   rpmsg_dev_cb_t    device_destroy;
   rpmsg_match_cb_t  ns_match;
   rpmsg_bind_cb_t   ns_bind;
-  struct metal_list node;
+  struct list_node  node;
 };
 
 struct rpmsg_ioctl_s
@@ -80,8 +83,8 @@ static int rpmsg_dev_ioctl(FAR struct file *filep, int cmd,
  * Private Data
  ****************************************************************************/
 
-static METAL_DECLARE_LIST(g_rpmsg_cb);
-static METAL_DECLARE_LIST(g_rpmsg);
+static struct list_node g_rpmsg_cb = LIST_INITIAL_VALUE(g_rpmsg_cb);
+static struct list_node g_rpmsg = LIST_INITIAL_VALUE(g_rpmsg);
 
 static rw_semaphore_t g_rpmsg_lock = RWSEM_INITIALIZER;
 
@@ -173,8 +176,7 @@ static int rpmsg_dev_ioctl_(FAR struct rpmsg_s *rpmsg, int 
cmd,
 static int rpmsg_panic_notifier(FAR struct notifier_block *nb,
                                 unsigned long action, FAR void *data)
 {
-  FAR struct rpmsg_s *rpmsg = metal_container_of(nb, struct rpmsg_s,
-                                                 nbpanic);
+  FAR struct rpmsg_s *rpmsg = container_of(nb, struct rpmsg_s, nbpanic);
   int ret = OK;
 
   if (action == PANIC_KERNEL_FINAL)
@@ -287,8 +289,8 @@ int rpmsg_register_callback(FAR void *priv,
                             rpmsg_match_cb_t ns_match,
                             rpmsg_bind_cb_t ns_bind)
 {
-  FAR struct metal_list *node;
-  FAR struct metal_list *bnode;
+  FAR struct rpmsg_bind_s *bind;
+  FAR struct rpmsg_s *rpmsg;
   FAR struct rpmsg_cb_s *cb;
 
   cb = kmm_zalloc(sizeof(struct rpmsg_cb_s));
@@ -304,12 +306,10 @@ int rpmsg_register_callback(FAR void *priv,
   cb->ns_bind        = ns_bind;
 
   down_write(&g_rpmsg_lock);
-  metal_list_add_tail(&g_rpmsg_cb, &cb->node);
+  list_add_tail(&g_rpmsg_cb, &cb->node);
   downgrade_write(&g_rpmsg_lock);
-  metal_list_for_each(&g_rpmsg, node)
+  list_for_every_entry(&g_rpmsg, rpmsg, struct rpmsg_s, node)
     {
-      FAR struct rpmsg_s *rpmsg =
-        metal_container_of(node, struct rpmsg_s, node);
       FAR struct rpmsg_device *rdev = rpmsg_get_rdev_by_rpmsg(rpmsg);
 
       if (!rpmsg->init)
@@ -331,14 +331,11 @@ int rpmsg_register_callback(FAR void *priv,
 
 again:
       nxrmutex_lock(&rpmsg->lock);
-      metal_list_for_each(&rpmsg->bind, bnode)
+      list_for_every_entry(&rpmsg->bind, bind, struct rpmsg_bind_s, node)
         {
-          FAR struct rpmsg_bind_s *bind =
-            metal_container_of(bnode, struct rpmsg_bind_s, node);
-
           if (ns_match(rdev, priv, bind->name, bind->dest))
             {
-              metal_list_del(bnode);
+              list_delete(&bind->node);
               nxrmutex_unlock(&rpmsg->lock);
               ns_bind(rdev, priv, bind->name, bind->dest);
 
@@ -361,22 +358,19 @@ void rpmsg_unregister_callback(FAR void *priv,
                                rpmsg_match_cb_t ns_match,
                                rpmsg_bind_cb_t ns_bind)
 {
-  FAR struct metal_list *node;
-  FAR struct metal_list *pnode;
+  FAR struct rpmsg_cb_s *cb;
+  FAR struct rpmsg_s *rpmsg;
 
   down_write(&g_rpmsg_lock);
-  metal_list_for_each(&g_rpmsg_cb, node)
+  list_for_every_entry(&g_rpmsg_cb, cb, struct rpmsg_cb_s, node)
     {
-      FAR struct rpmsg_cb_s *cb =
-        metal_container_of(node, struct rpmsg_cb_s, node);
-
       if (cb->priv == priv &&
           cb->device_created == device_created &&
           cb->device_destroy == device_destroy &&
           cb->ns_match == ns_match &&
           cb->ns_bind == ns_bind)
         {
-          metal_list_del(&cb->node);
+          list_delete(&cb->node);
           kmm_free(cb);
           break;
         }
@@ -385,10 +379,8 @@ void rpmsg_unregister_callback(FAR void *priv,
   downgrade_write(&g_rpmsg_lock);
   if (device_destroy)
     {
-      metal_list_for_each(&g_rpmsg, pnode)
+      list_for_every_entry(&g_rpmsg, rpmsg, struct rpmsg_s, node)
         {
-          FAR struct rpmsg_s *rpmsg =
-            metal_container_of(pnode, struct rpmsg_s, node);
           FAR struct rpmsg_device *rdev = rpmsg_get_rdev_by_rpmsg(rpmsg);
 
           if (rpmsg->init)
@@ -406,14 +398,11 @@ void rpmsg_ns_bind(FAR struct rpmsg_device *rdev,
 {
   FAR struct rpmsg_s *rpmsg = rpmsg_get_by_rdev(rdev);
   FAR struct rpmsg_bind_s *bind;
-  FAR struct metal_list *node;
+  FAR struct rpmsg_cb_s *cb;
 
   down_read(&g_rpmsg_lock);
-  metal_list_for_each(&g_rpmsg_cb, node)
+  list_for_every_entry(&g_rpmsg_cb, cb, struct rpmsg_cb_s, node)
     {
-      FAR struct rpmsg_cb_s *cb =
-        metal_container_of(node, struct rpmsg_cb_s, node);
-
       if (cb->ns_match && cb->ns_match(rdev, cb->priv, name, dest))
         {
           rpmsg_bind_cb_t ns_bind = cb->ns_bind;
@@ -436,7 +425,7 @@ void rpmsg_ns_bind(FAR struct rpmsg_device *rdev,
   strlcpy(bind->name, name, RPMSG_NAME_SIZE);
 
   nxrmutex_lock(&rpmsg->lock);
-  metal_list_add_tail(&rpmsg->bind, &bind->node);
+  list_add_tail(&rpmsg->bind, &bind->node);
   nxrmutex_unlock(&rpmsg->lock);
 
   up_read(&g_rpmsg_lock);
@@ -446,17 +435,14 @@ void rpmsg_ns_unbind(FAR struct rpmsg_device *rdev,
                      FAR const char *name, uint32_t dest)
 {
   FAR struct rpmsg_s *rpmsg = rpmsg_get_by_rdev(rdev);
-  FAR struct metal_list *node;
+  FAR struct rpmsg_bind_s *bind;
 
   nxrmutex_lock(&rpmsg->lock);
-  metal_list_for_each(&rpmsg->bind, node)
+  list_for_every_entry(&rpmsg->bind, bind, struct rpmsg_bind_s, node)
     {
-      FAR struct rpmsg_bind_s *bind =
-        metal_container_of(node, struct rpmsg_bind_s, node);
-
       if (bind->dest == dest && !strncmp(bind->name, name, RPMSG_NAME_SIZE))
         {
-          metal_list_del(node);
+          list_delete(&bind->node);
           kmm_free(bind);
           break;
         }
@@ -468,15 +454,12 @@ void rpmsg_ns_unbind(FAR struct rpmsg_device *rdev,
 void rpmsg_device_created(FAR struct rpmsg_s *rpmsg)
 {
   FAR struct rpmsg_device *rdev = rpmsg_get_rdev_by_rpmsg(rpmsg);
-  FAR struct metal_list *node;
-  FAR struct metal_list *tmp;
+  FAR struct rpmsg_cb_s *tmp;
+  FAR struct rpmsg_cb_s *cb;
 
   down_write(&g_rpmsg_lock);
-  metal_list_for_each_safe(&g_rpmsg_cb, tmp, node)
+  list_for_every_entry_safe(&g_rpmsg_cb, cb, tmp, struct rpmsg_cb_s, node)
     {
-      FAR struct rpmsg_cb_s *cb =
-        metal_container_of(node, struct rpmsg_cb_s, node);
-
       if (cb->device_created)
         {
           cb->device_created(rdev, cb->priv);
@@ -500,9 +483,13 @@ void rpmsg_device_created(FAR struct rpmsg_s *rpmsg)
 void rpmsg_device_destroy(FAR struct rpmsg_s *rpmsg)
 {
   FAR struct rpmsg_device *rdev = rpmsg_get_rdev_by_rpmsg(rpmsg);
+  FAR struct rpmsg_bind_s *bind_tmp;
+  FAR struct rpmsg_bind_s *bind;
+  FAR struct rpmsg_cb_s *cb_tmp;
+  FAR struct rpmsg_cb_s *cb;
+  FAR struct rpmsg_endpoint *ept;
   FAR struct metal_list *node;
   FAR struct metal_list *tmp;
-  FAR struct rpmsg_endpoint *ept;
 
 #ifdef CONFIG_RPMSG_PING
   rpmsg_ping_deinit(&rpmsg->ping);
@@ -517,12 +504,10 @@ void rpmsg_device_destroy(FAR struct rpmsg_s *rpmsg)
 #endif
 
   nxrmutex_lock(&rpmsg->lock);
-  metal_list_for_each_safe(&rpmsg->bind, tmp, node)
+  list_for_every_entry_safe(&rpmsg->bind, bind, bind_tmp,
+                            struct rpmsg_bind_s, node)
     {
-      FAR struct rpmsg_bind_s *bind =
-        metal_container_of(node, struct rpmsg_bind_s, node);
-
-      metal_list_del(node);
+      list_delete(&bind->node);
       kmm_free(bind);
     }
 
@@ -533,11 +518,8 @@ void rpmsg_device_destroy(FAR struct rpmsg_s *rpmsg)
   down_write(&g_rpmsg_lock);
   rpmsg->init = false;
   downgrade_write(&g_rpmsg_lock);
-  metal_list_for_each_safe(&g_rpmsg_cb, tmp, node)
+  list_for_every_entry_safe(&g_rpmsg_cb, cb, cb_tmp, struct rpmsg_cb_s, node)
     {
-      FAR struct rpmsg_cb_s *cb =
-        metal_container_of(node, struct rpmsg_cb_s, node);
-
       if (cb->device_destroy)
         {
           cb->device_destroy(rdev, cb->priv);
@@ -552,7 +534,7 @@ void rpmsg_device_destroy(FAR struct rpmsg_s *rpmsg)
 
   metal_list_for_each_safe(&rdev->endpoints, tmp, node)
     {
-      ept = metal_container_of(node, struct rpmsg_endpoint, node);
+      ept = container_of(node, struct rpmsg_endpoint, node);
       if (ept->ns_unbind_cb)
         {
           ept->ns_unbind_cb(ept);
@@ -583,7 +565,7 @@ int rpmsg_register(FAR const char *path, FAR struct rpmsg_s 
*rpmsg,
       return ret;
     }
 
-  metal_list_init(&rpmsg->bind);
+  list_initialize(&rpmsg->bind);
   nxrmutex_init(&rpmsg->lock);
   rpmsg->ops = ops;
   atomic_set(&rpmsg->signals, RPMSG_SIGNAL_RUNNING);
@@ -591,7 +573,7 @@ int rpmsg_register(FAR const char *path, FAR struct rpmsg_s 
*rpmsg,
   /* Add priv to list */
 
   down_write(&g_rpmsg_lock);
-  metal_list_add_tail(&g_rpmsg, &rpmsg->node);
+  list_add_tail(&g_rpmsg, &rpmsg->node);
   up_write(&g_rpmsg_lock);
 
 #if CONFIG_RPMSG_PANIC_DUMP_LEVEL > RPMSG_PANIC_DUMP_DISABLE
@@ -610,7 +592,7 @@ void rpmsg_unregister(FAR const char *path, FAR struct 
rpmsg_s *rpmsg)
 #endif
 
   down_write(&g_rpmsg_lock);
-  metal_list_del(&rpmsg->node);
+  list_delete(&rpmsg->node);
   up_write(&g_rpmsg_lock);
 
   nxrmutex_destroy(&rpmsg->lock);
@@ -628,14 +610,14 @@ void rpmsg_dump_epts(FAR struct rpmsg_device *rdev)
   FAR struct rpmsg_endpoint *ept;
   FAR struct metal_list *node;
 
-  metal_log(METAL_LOG_EMERGENCY, "  rpmsg ept list:\n");
+  syslog(LOG_EMERG, "  rpmsg ept list:\n");
   metal_list_for_each(&rdev->endpoints, node)
     {
-      ept = metal_container_of(node, struct rpmsg_endpoint, node);
-      metal_log(METAL_LOG_EMERGENCY, "    ept %s %p: addr=%" PRIu32 " "
-                "dest=%" PRIu32 " refcnt=%" PRIu32 " priority=%" PRIu8
-                " priv=%p\n", ept->name, ept, ept->addr, ept->dest_addr,
-                ept->refcnt, ept->priority, ept->priv);
+      ept = container_of(node, struct rpmsg_endpoint, node);
+      syslog(LOG_EMERG, "    ept %s %p: addr=%" PRIu32 " "
+             "dest=%" PRIu32 " refcnt=%" PRIu32 " priority=%" PRIu8
+             " priv=%p\n", ept->name, ept, ept->addr, ept->dest_addr,
+             ept->refcnt, ept->priority, ept->priv);
     }
 }
 
@@ -674,8 +656,8 @@ void rpmsg_dump_all(void)
 
 int rpmsg_foreach(rpmsg_foreach_t handler, FAR void *args)
 {
-  FAR struct metal_list *node;
   bool needlock = !up_interrupt_context() && !sched_idletask();
+  FAR struct rpmsg_s *rpmsg;
   int ret = OK;
 
   if (needlock)
@@ -683,11 +665,8 @@ int rpmsg_foreach(rpmsg_foreach_t handler, FAR void *args)
       down_read(&g_rpmsg_lock);
     }
 
-  metal_list_for_each(&g_rpmsg, node)
+  list_for_every_entry(&g_rpmsg, rpmsg, struct rpmsg_s, node)
     {
-      FAR struct rpmsg_s *rpmsg =
-        metal_container_of(node, struct rpmsg_s, node);
-
       ret = handler(rpmsg, args);
       if (ret < 0)
         {
@@ -724,7 +703,7 @@ void rpmsg_modify_signals(FAR struct rpmsg_s *rpmsg,
 
   metal_list_for_each(&rdev->endpoints, node)
     {
-      ept = metal_container_of(node, struct rpmsg_endpoint, node);
+      ept = container_of(node, struct rpmsg_endpoint, node);
       if (!strncmp(ept->name, RPMSG_ROUTER_NAME,
                    RPMSG_ROUTER_NAME_LEN))
         {
diff --git a/drivers/rpmsg/rpmsg.h b/drivers/rpmsg/rpmsg.h
index 168e09c8b0b..c69e3a3bffa 100644
--- a/drivers/rpmsg/rpmsg.h
+++ b/drivers/rpmsg/rpmsg.h
@@ -27,6 +27,7 @@
 
 #ifdef CONFIG_RPMSG
 
+#include <nuttx/list.h>
 #include <nuttx/panic_notifier.h>
 #include <nuttx/rpmsg/rpmsg.h>
 
@@ -47,9 +48,9 @@
 struct rpmsg_s
 {
   bool                         init;
-  struct metal_list            bind;
+  struct list_node             bind;
   rmutex_t                     lock;
-  struct metal_list            node;
+  struct list_node             node;
   char                         local_cpuname[RPMSG_NAME_SIZE];
   char                         cpuname[RPMSG_NAME_SIZE];
   FAR const struct rpmsg_ops_s *ops;
diff --git a/drivers/rpmsg/rpmsg_port.c b/drivers/rpmsg/rpmsg_port.c
index b49058c1e3b..8d8c82f170b 100644
--- a/drivers/rpmsg/rpmsg_port.c
+++ b/drivers/rpmsg/rpmsg_port.c
@@ -27,13 +27,12 @@
 #include <nuttx/debug.h>
 #include <execinfo.h>
 #include <stdio.h>
+#include <syslog.h>
 #include <time.h>
 
 #include <nuttx/irq.h>
 #include <nuttx/kmalloc.h>
-
-#include <metal/mutex.h>
-#include <metal/sys.h>
+#include <nuttx/nuttx.h>
 
 #include "rpmsg_port.h"
 
@@ -46,6 +45,10 @@
 #define RPMSG_PORT_BUF_TO_NODE(q,b) ((q)->node + ((FAR void *)(b) - (q)->buf) 
/ (q)->len)
 #define RPMSG_PORT_NODE_TO_BUF(q,n) ((q)->buf + (((n) - (q)->node)) * (q)->len)
 
+#define rpmsg_port_from_rdev(d) container_of(d, struct rpmsg_port_s, rdev)
+#define rpmsg_port_hdr_from_buf(r) \
+  container_of(r, struct rpmsg_port_header_s, buf)
+
 /****************************************************************************
  * Private Function Prototypes
  ****************************************************************************/
@@ -121,7 +124,7 @@ rpmsg_port_remove_node(FAR struct rpmsg_port_list_s *list)
     }
 
   spin_unlock_irqrestore(&list->lock, flags);
-  return metal_container_of(node, struct rpmsg_port_node_s, node);
+  return container_of(node, struct rpmsg_port_node_s, node);
 }
 
 /****************************************************************************
@@ -248,8 +251,7 @@ rpmsg_port_get_tx_payload_buffer(FAR struct rpmsg_device 
*rdev,
                                  FAR uint32_t *len, int wait,
                                  uint8_t priority)
 {
-  FAR struct rpmsg_port_s *port =
-    metal_container_of(rdev, struct rpmsg_port_s, rdev);
+  FAR struct rpmsg_port_s *port = rpmsg_port_from_rdev(rdev);
   FAR struct rpmsg_port_header_s *hdr =
     rpmsg_port_queue_get_available_buffer(&port->txq, wait);
 
@@ -272,8 +274,7 @@ static int rpmsg_port_send_offchannel_nocopy(FAR struct 
rpmsg_device *rdev,
                                              uint32_t src, uint32_t dst,
                                              FAR const void *data, int len)
 {
-  FAR struct rpmsg_port_s *port =
-    metal_container_of(rdev, struct rpmsg_port_s, rdev);
+  FAR struct rpmsg_port_s *port = rpmsg_port_from_rdev(rdev);
   FAR struct rpmsg_port_header_s *hdr;
   FAR struct rpmsg_hdr *rphdr;
 
@@ -284,7 +285,7 @@ static int rpmsg_port_send_offchannel_nocopy(FAR struct 
rpmsg_device *rdev,
   rphdr->reserved = 0;
   rphdr->flags = 0;
 
-  hdr = metal_container_of(rphdr, struct rpmsg_port_header_s, buf);
+  hdr = rpmsg_port_hdr_from_buf(rphdr);
   hdr->len = sizeof(struct rpmsg_port_header_s) +
              sizeof(struct rpmsg_hdr) + len;
 
@@ -340,11 +341,9 @@ static void rpmsg_port_hold_rx_buffer(FAR struct 
rpmsg_device *rdev,
 static void rpmsg_port_release_rx_buffer(FAR struct rpmsg_device *rdev,
                                          FAR void *rxbuf)
 {
-  FAR struct rpmsg_port_s *port =
-    metal_container_of(rdev, struct rpmsg_port_s, rdev);
+  FAR struct rpmsg_port_s *port = rpmsg_port_from_rdev(rdev);
   FAR struct rpmsg_hdr *rphdr = RPMSG_LOCATE_HDR(rxbuf);
-  FAR struct rpmsg_port_header_s *hdr =
-    metal_container_of(rphdr, struct rpmsg_port_header_s, buf);
+  FAR struct rpmsg_port_header_s *hdr = rpmsg_port_hdr_from_buf(rphdr);
   uint32_t reserved =
     atomic_sub(&rphdr->reserved, 1 << RPMSG_BUF_HELD_SHIFT);
 
@@ -365,11 +364,9 @@ static void rpmsg_port_release_rx_buffer(FAR struct 
rpmsg_device *rdev,
 static int rpmsg_port_release_tx_buffer(FAR struct rpmsg_device *rdev,
                                         FAR void *txbuf)
 {
-  FAR struct rpmsg_port_s *port =
-    metal_container_of(rdev, struct rpmsg_port_s, rdev);
+  FAR struct rpmsg_port_s *port = rpmsg_port_from_rdev(rdev);
   FAR struct rpmsg_hdr *rphdr = RPMSG_LOCATE_HDR(txbuf);
-  FAR struct rpmsg_port_header_s *hdr =
-    metal_container_of(rphdr, struct rpmsg_port_header_s, buf);
+  FAR struct rpmsg_port_header_s *hdr = rpmsg_port_hdr_from_buf(rphdr);
 
   rpmsg_port_queue_return_buffer(&port->txq, hdr);
   return RPMSG_SUCCESS;
@@ -381,8 +378,7 @@ static int rpmsg_port_release_tx_buffer(FAR struct 
rpmsg_device *rdev,
 
 static int rpmsg_port_get_tx_buffer_size(FAR struct rpmsg_device *rdev)
 {
-  FAR struct rpmsg_port_s *port =
-    metal_container_of(rdev, struct rpmsg_port_s, rdev);
+  FAR struct rpmsg_port_s *port = rpmsg_port_from_rdev(rdev);
 
   return port->txq.len - sizeof(struct rpmsg_port_header_s) -
          sizeof(struct rpmsg_hdr) - sizeof(struct rpmsg_timestamp_s);
@@ -394,8 +390,7 @@ static int rpmsg_port_get_tx_buffer_size(FAR struct 
rpmsg_device *rdev)
 
 static int rpmsg_port_get_rx_buffer_size(FAR struct rpmsg_device *rdev)
 {
-  FAR struct rpmsg_port_s *port =
-    metal_container_of(rdev, struct rpmsg_port_s, rdev);
+  FAR struct rpmsg_port_s *port = rpmsg_port_from_rdev(rdev);
 
   return port->rxq.len - sizeof(struct rpmsg_port_header_s) -
          sizeof(struct rpmsg_hdr) - sizeof(struct rpmsg_timestamp_s);
@@ -411,8 +406,7 @@ static int rpmsg_port_get_timestamp(FAR struct rpmsg_s 
*rpmsg,
 {
   FAR struct rpmsg_port_s *port = (FAR struct rpmsg_port_s *)rpmsg;
   FAR const struct rpmsg_hdr *rphdr = RPMSG_LOCATE_HDR(data);
-  FAR const struct rpmsg_port_header_s *hdr =
-    metal_container_of(rphdr, struct rpmsg_port_header_s, buf);
+  FAR const struct rpmsg_port_header_s *hdr = rpmsg_port_hdr_from_buf(rphdr);
   FAR const struct rpmsg_timestamp_s *rpts =
     (FAR const struct rpmsg_timestamp_s *)((uint8_t *)hdr + port->rxq.len -
                                            sizeof(struct rpmsg_timestamp_s));
@@ -867,12 +861,10 @@ static void rpmsg_port_dump_buffer(FAR struct 
rpmsg_device *rdev,
   FAR struct rpmsg_port_node_s *node;
   irqstate_t flags = spin_lock_irqsave(&queue->ready.lock);
 
-  metal_log(METAL_LOG_EMERGENCY,
-            "rpmsg_port queue %s: {used: %u, avail: %u}\n",
-            rx ? "RX" : "TX",
-            rpmsg_port_queue_nused(queue),
-            rpmsg_port_queue_navail(queue));
-  metal_log(METAL_LOG_EMERGENCY, "rpmsg buffer list:\n");
+  syslog(LOG_EMERG, "rpmsg_port queue %s: {used: %u, avail: %u}\n",
+         rx ? "RX" : "TX", rpmsg_port_queue_nused(queue),
+         rpmsg_port_queue_navail(queue));
+  syslog(LOG_EMERG, "rpmsg buffer list:\n");
   list_for_every_entry(&queue->ready.head, node,
                        struct rpmsg_port_node_s, node)
     {
@@ -884,8 +876,8 @@ static void rpmsg_port_dump_buffer(FAR struct rpmsg_device 
*rdev,
       ept = rpmsg_get_ept_from_addr(rdev, rx ? rphdr->dst : rphdr->src);
       if (ept)
         {
-          metal_log(METAL_LOG_EMERGENCY, " %s buffer %p hold by %s\n",
-                    rx ? "RX" : "TX", rphdr, ept->name);
+          syslog(LOG_EMERG, " %s buffer %p hold by %s\n",
+                 rx ? "RX" : "TX", rphdr, ept->name);
         }
     }
 
@@ -902,8 +894,8 @@ static void rpmsg_port_dump(FAR struct rpmsg_s *rpmsg, bool 
verbose)
   FAR struct rpmsg_device *rdev = rpmsg_get_rdev_by_rpmsg(rpmsg);
 
   metal_mutex_acquire(&rdev->lock);
-  metal_log(METAL_LOG_EMERGENCY, "Remote: %s state: %d\n",
-            port->rpmsg.cpuname, rpmsg_is_running(rdev));
+  syslog(LOG_EMERG, "Remote: %s state: %d\n",
+         port->rpmsg.cpuname, rpmsg_is_running(rdev));
   if (verbose)
     {
       rpmsg_dump_epts(rdev);
diff --git a/drivers/rpmsg/rpmsg_router_edge.c 
b/drivers/rpmsg/rpmsg_router_edge.c
index 52c99f6e84d..b80f01943e2 100644
--- a/drivers/rpmsg/rpmsg_router_edge.c
+++ b/drivers/rpmsg/rpmsg_router_edge.c
@@ -33,6 +33,7 @@
 #include <stdbool.h>
 
 #include <nuttx/kmalloc.h>
+#include <nuttx/nuttx.h>
 
 #include "rpmsg_router.h"
 
@@ -54,7 +55,7 @@
  ****************************************************************************/
 
 #define rpmsg_router_edge_from_rdev(d) \
-  metal_container_of(d, struct rpmsg_router_edge_s, rdev)
+  container_of(d, struct rpmsg_router_edge_s, rdev)
 
 #define RPMSG_ROUTER_EDGE_NAME_SIZE (2 * RPMSG_NAME_SIZE)
 
diff --git a/drivers/rpmsg/rpmsg_virtio.c b/drivers/rpmsg/rpmsg_virtio.c
index c5763e359a5..b8097b6b375 100644
--- a/drivers/rpmsg/rpmsg_virtio.c
+++ b/drivers/rpmsg/rpmsg_virtio.c
@@ -27,16 +27,17 @@
 #include <nuttx/debug.h>
 #include <stdio.h>
 #include <stdbool.h>
+#include <syslog.h>
 
 #include <nuttx/kmalloc.h>
 #include <nuttx/kthread.h>
+#include <nuttx/nuttx.h>
 #include <nuttx/power/pm.h>
 #include <nuttx/rpmsg/rpmsg_virtio.h>
 #include <nuttx/semaphore.h>
 #include <nuttx/spinlock.h>
 #include <nuttx/virtio/virtio-config.h>
 #include <nuttx/wdog.h>
-#include <metal/utilities.h>
 #include <openamp/rpmsg_virtio.h>
 
 #include "rpmsg.h"
@@ -300,7 +301,7 @@ static void rpmsg_virtio_rx_worker(FAR struct 
rpmsg_virtio_priv_s *priv)
   while ((tmp = metal_list_first(&priv->readyrx)) != NULL)
     {
       metal_list_del(tmp);
-      node = metal_container_of(tmp, struct rpmsg_virtio_node_s, node);
+      node = container_of(tmp, struct rpmsg_virtio_node_s, node);
       hdr = node->hdr;
       metal_list_add_tail(&priv->freerx, &node->node);
 
@@ -445,21 +446,17 @@ static void rpmsg_virtio_dump_buffer(FAR struct 
rpmsg_virtio_device *rvdev,
 
   if (rx)
     {
-      metal_log(METAL_LOG_EMERGENCY, "    RX buffer total %d\n",
-                vq->vq_nentries);
-      metal_log(METAL_LOG_EMERGENCY, "      unretrieved %d\n", unretrieved);
-      metal_log(METAL_LOG_EMERGENCY, "      retrieved %d\n",
-                vq->vq_queued_cnt);
-      metal_log(METAL_LOG_EMERGENCY, "      pending %d:\n", num);
+      syslog(LOG_EMERG, "    RX buffer total %d\n", vq->vq_nentries);
+      syslog(LOG_EMERG, "      unretrieved %d\n", unretrieved);
+      syslog(LOG_EMERG, "      retrieved %d\n", vq->vq_queued_cnt);
+      syslog(LOG_EMERG, "      pending %d:\n", num);
     }
   else
     {
-      metal_log(METAL_LOG_EMERGENCY, "    TX buffer total %d\n",
-                vq->vq_nentries);
-      metal_log(METAL_LOG_EMERGENCY, "      unretrieved %d\n", unretrieved);
-      metal_log(METAL_LOG_EMERGENCY, "      retrieved %d\n",
-                vq->vq_free_cnt);
-      metal_log(METAL_LOG_EMERGENCY, "      sent %d:\n", num);
+      syslog(LOG_EMERG, "    TX buffer total %d\n", vq->vq_nentries);
+      syslog(LOG_EMERG, "      unretrieved %d\n", unretrieved);
+      syslog(LOG_EMERG, "      retrieved %d\n", vq->vq_free_cnt);
+      syslog(LOG_EMERG, "      sent %d:\n", num);
     }
 
   for (i = 0; i < num; i++)
@@ -507,9 +504,8 @@ static void rpmsg_virtio_dump_buffer(FAR struct 
rpmsg_virtio_device *rvdev,
                                         rx ? hdr->dst : hdr->src);
           if (ept)
             {
-              metal_log(METAL_LOG_EMERGENCY,
-                        "        %s buffer %p hold by %s\n",
-                        rx ? "RX" : "TX", hdr, ept->name);
+              syslog(LOG_EMERG, "        %s buffer %p hold by %s\n",
+                     rx ? "RX" : "TX", hdr, ept->name);
             }
         }
     }
@@ -526,10 +522,9 @@ static void rpmsg_virtio_dump(FAR struct rpmsg_s *rpmsg, 
bool verbose)
   FAR struct rpmsg_virtio_device *rvdev = &priv->rvdev;
   FAR struct rpmsg_device *rdev = &rvdev->rdev;
 
-  metal_log(METAL_LOG_EMERGENCY,
-            "Local: %s Remote: %s Headrx %u Headtx %u\n",
-            priv->rpmsg.local_cpuname, priv->rpmsg.cpuname, priv->headrx,
-            priv->headtx);
+  syslog(LOG_EMERG, "Local: %s Remote: %s Headrx %u Headtx %u\n",
+         priv->rpmsg.local_cpuname, priv->rpmsg.cpuname, priv->headrx,
+         priv->headtx);
 
   if (!rvdev->vdev || !rdev->ns_unbind_cb)
     {
@@ -539,23 +534,22 @@ static void rpmsg_virtio_dump(FAR struct rpmsg_s *rpmsg, 
bool verbose)
   metal_mutex_acquire(&rdev->lock);
   if (verbose)
     {
-      metal_log(METAL_LOG_EMERGENCY,
-                "Dump rpmsg info between cpu (master: %s)%s <==> %s:\n",
-                rpmsg_virtio_get_role(rvdev) == RPMSG_HOST ?
-                "yes" : "no", priv->rpmsg.local_cpuname,
-                priv->rpmsg.cpuname);
+      syslog(LOG_EMERG,
+             "Dump rpmsg info between cpu (master: %s)%s <==> %s:\n",
+             rpmsg_virtio_get_role(rvdev) == RPMSG_HOST ?
+             "yes" : "no", priv->rpmsg.local_cpuname, priv->rpmsg.cpuname);
 
       rpmsg_dump_epts(rdev);
     }
 
-  metal_log(METAL_LOG_EMERGENCY, "rpmsg vq RX:\n");
+  syslog(LOG_EMERG, "rpmsg vq RX:\n");
   virtqueue_dump(rvdev->rvq);
-  metal_log(METAL_LOG_EMERGENCY, "rpmsg vq TX:\n");
+  syslog(LOG_EMERG, "rpmsg vq TX:\n");
   virtqueue_dump(rvdev->svq);
 
   if (verbose)
     {
-      metal_log(METAL_LOG_EMERGENCY, "  rpmsg buffer list:\n");
+      syslog(LOG_EMERG, "  rpmsg buffer list:\n");
       rpmsg_virtio_dump_buffer(rvdev, true);
       rpmsg_virtio_dump_buffer(rvdev, false);
     }
@@ -614,7 +608,7 @@ static void rpmsg_virtio_rx_enqueue(FAR struct 
rpmsg_virtio_priv_s *priv,
   tmp = metal_list_first(&priv->freerx);
   DEBUGASSERT(tmp != NULL);
   metal_list_del(tmp);
-  node = metal_container_of(tmp, struct rpmsg_virtio_node_s, node);
+  node = container_of(tmp, struct rpmsg_virtio_node_s, node);
   node->hdr = hdr;
   metal_list_add_tail(&priv->readyrx, &node->node);
 }
@@ -705,7 +699,7 @@ static void rpmsg_virtio_rx_dispatch(FAR struct 
rpmsg_virtio_priv_s *priv)
 static void rpmsg_virtio_rx_callback(FAR struct virtqueue *vq)
 {
   FAR struct rpmsg_virtio_priv_s *priv =
-    metal_container_of(vq->vq_dev->priv, struct rpmsg_virtio_priv_s, rvdev);
+    container_of(vq->vq_dev->priv, struct rpmsg_virtio_priv_s, rvdev);
 
   if (priv->init)
     {
@@ -723,7 +717,7 @@ static void rpmsg_virtio_rx_callback(FAR struct virtqueue 
*vq)
 static void rpmsg_virtio_tx_callback(FAR struct virtqueue *vq)
 {
   FAR struct rpmsg_virtio_priv_s *priv =
-    metal_container_of(vq->vq_dev->priv, struct rpmsg_virtio_priv_s, rvdev);
+    container_of(vq->vq_dev->priv, struct rpmsg_virtio_priv_s, rvdev);
 
   rpmsg_virtio_tx_wakeup(priv);
 
@@ -742,7 +736,7 @@ static void rpmsg_virtio_tx_callback(FAR struct virtqueue 
*vq)
 static void rpmsg_virtio_tx_notify(FAR struct virtqueue *vq)
 {
   FAR struct rpmsg_virtio_priv_s *priv =
-    metal_container_of(vq->vq_dev->priv, struct rpmsg_virtio_priv_s, rvdev);
+    container_of(vq->vq_dev->priv, struct rpmsg_virtio_priv_s, rvdev);
 
   /* rpmsg_virtio_tx_notify() called normally means send the buffer to peer,
    * so call rpmsg_virtio_pm_action(true) to hold the pm wakelock to avoid to
@@ -762,7 +756,7 @@ static int rpmsg_virtio_notify_wait(FAR struct rpmsg_device 
*rdev,
                                     uint32_t id)
 {
   FAR struct rpmsg_virtio_priv_s *priv =
-    metal_container_of(rdev, struct rpmsg_virtio_priv_s, rvdev);
+    container_of(rdev, struct rpmsg_virtio_priv_s, rvdev);
 
   if (!rpmsg_virtio_is_recursive(priv))
     {
@@ -1049,7 +1043,7 @@ int rpmsg_virtio_probe(FAR struct virtio_device *vdev)
 void rpmsg_virtio_remove(FAR struct virtio_device *vdev)
 {
   FAR struct rpmsg_virtio_priv_s *priv =
-    metal_container_of(vdev->priv, struct rpmsg_virtio_priv_s, rvdev);
+    container_of(vdev->priv, struct rpmsg_virtio_priv_s, rvdev);
   char name[64];
 
 #ifdef CONFIG_RPMSG_VIRTIO_PM

Reply via email to