Apply suggestion

Author: Cuda-Chen

utils.h

@@ -16,58 +16,57 @@ void semu_timer_rebase(semu_timer_t *timer, uint64_t time);
 /* Linux-like queue API */
 
 #if defined(__GNUC__)
-#define __QUEUE_HAVE_TYPEOF 1
+#define __list_HAVE_TYPEOF 1
 #endif
 
-/* Merely a doubly-linked list */
-struct queue_head {
-    struct queue_head *prev, *next;
+struct list_head {
+    struct list_head *prev, *next;
 };
 
-#define QUEUE_HEAD(head) struct queue_head head = {&(head), &(head)}
+#define list_HEAD(head) struct list_head head = {&(head), &(head)}
 
-static inline void INIT_QUEUE_HEAD(struct queue_head *head)
+static inline void INIT_LIST_HEAD(struct list_head *head)
 {
     head->next = head;
     head->prev = head;
 }
 
-/* Push the node to the end of queue */
-static inline void queue_push(struct queue_head *node, struct queue_head *head)
+/* Push the node to the end of list */
+static inline void list_push(struct list_head *node, struct list_head *head)
 {
-    struct queue_head *prev = head->prev;
+    struct list_head *prev = head->prev;
 
     prev->next = node;
     node->next = head;
     node->prev = prev;
     head->prev = node;
 }
 
-static inline int queue_empty(const struct queue_head *head)
+static inline int list_empty(const struct list_head *head)
 {
     return (head->next == head);
 }
 
-static inline void queue_del(struct queue_head *node)
+static inline void list_del(struct list_head *node)
 {
-    struct queue_head *next = node->next;
-    struct queue_head *prev = node->prev;
+    struct list_head *next = node->next;
+    struct list_head *prev = node->prev;
 
     next->prev = prev;
     prev->next = next;
 
-    node->prev = (struct queue_head *) (0x00100100);
-    node->next = (struct queue_head *) (0x00200200);
+    node->prev = (struct list_head *) (0x00100100);
+    node->next = (struct list_head *) (0x00200200);
 }
 
-static inline void queue_del_init(struct queue_head *node)
+static inline void list_del_init(struct list_head *node)
 {
-    queue_del(node);
-    INIT_QUEUE_HEAD(node);
+    list_del(node);
+    INIT_LIST_HEAD(node);
 }
 
 #ifndef container_of
-#ifdef __QUEUE_HAVE_TYPEOF
+#ifdef __list_HAVE_TYPEOF
 #define container_of(ptr, type, member)                            \
     __extension__({                                                \
         const __typeof__(((type *) 0)->member) *__pmember = (ptr); \
@@ -79,30 +78,30 @@ static inline void queue_del_init(struct queue_head *node)
 #endif
 #endif
 
-#define queue_entry(node, type, member) container_of(node, type, member)
+#define list_entry(node, type, member) container_of(node, type, member)
 
-#define queue_first_entry(head, type, member) \
-    queue_entry((head)->next, type, member)
+#define list_first_entry(head, type, member) \
+    list_entry((head)->next, type, member)
 
-#define queue_last_entry(head, type, member) \
-    queue_entry((head)->prev, type, member)
+#define list_last_entry(head, type, member) \
+    list_entry((head)->prev, type, member)
 
-#define queue_for_each(node, head) \
+#define list_for_each(node, head) \
     for (node = (head)->next; node != (head); node = node->next)
 
-#ifdef __QUEUE_HAVE_TYPEOF
-#define queue_for_each_entry(entry, head, member)                       \
-    for (entry = queue_entry((head)->next, __typeof__(*entry), member); \
-         &entry->member != (head);                                      \
-         entry = queue_entry(entry->member.next, __typeof__(*entry), member))
+#ifdef __list_HAVE_TYPEOF
+#define list_for_each_entry(entry, head, member)                       \
+    for (entry = list_entry((head)->next, __typeof__(*entry), member); \
+         &entry->member != (head);                                     \
+         entry = list_entry(entry->member.next, __typeof__(*entry), member))
 #endif
 
-#define queue_for_each_safe(node, safe, head)                    \
+#define list_for_each_safe(node, safe, head)                     \
     for (node = (head)->next, safe = node->next; node != (head); \
          node = safe, safe = node->next)
 
-#define queue_for_each_entry_safe(entry, safe, head, member)                \
-    for (entry = queue_entry((head)->next, __typeof__(*entry), member),     \
-        safe = queue_entry(entry->member.next, __typeof__(*entry), member); \
-         &entry->member != (head); entry = safe,                            \
-        safe = queue_entry(safe->member.next, __typeof__(*entry), member))
+#define list_for_each_entry_safe(entry, safe, head, member)                \
+    for (entry = list_entry((head)->next, __typeof__(*entry), member),     \
+        safe = list_entry(entry->member.next, __typeof__(*entry), member); \
+         &entry->member != (head); entry = safe,                           \
+        safe = list_entry(safe->member.next, __typeof__(*entry), member))

virtio-snd.c

@@ -796,7 +796,7 @@ static void __virtio_snd_frame_enqueue(void *payload,
 
 typedef struct {
     struct virtq_desc vq_desc;
-    struct queue_head q;
+    struct list_head q;
 } virtq_desc_queue_node_t;
 static int virtio_snd_tx_desc_handler(virtio_snd_state_t *vsnd,
                                       const virtio_snd_queue_t *queue,
@@ -813,9 +813,9 @@ static int virtio_snd_tx_desc_handler(virtio_snd_state_t *vsnd,
      *   (response payload structure)
      */
     virtq_desc_queue_node_t *node;
-    struct queue_head q;
-    INIT_QUEUE_HEAD(&q);
-    assert(queue_empty(&q));
+    struct list_head q;
+    INIT_LIST_HEAD(&q);
+    assert(list_empty(&q));
 
     /* Collect the descriptors */
     int cnt = 0;
@@ -828,7 +828,7 @@ static int virtio_snd_tx_desc_handler(virtio_snd_state_t *vsnd,
         node->vq_desc.addr = desc[0];
         node->vq_desc.len = desc[2];
         node->vq_desc.flags = desc[3];
-        queue_push(&node->q, &q);
+        list_push(&node->q, &q);
         desc_idx = desc[3] >> 16; /* vq_desc[desc_cnt].next */
 
         cnt++;
@@ -844,8 +844,7 @@ static int virtio_snd_tx_desc_handler(virtio_snd_state_t *vsnd,
     uint32_t stream_id;
     uintptr_t base = (uintptr_t) vsnd->ram;
     uint32_t ret_len = 0;
-    queue_for_each_entry(node, &q, q)
-    {
+    list_for_each_entry (node, &q, q) {
         uint32_t addr = node->vq_desc.addr;
         uint32_t len = node->vq_desc.len;
         // fprintf(stderr, "idx %d addr %" PRIu32 " len %" PRIu32 "\n", idx,
@@ -882,9 +881,8 @@ static int virtio_snd_tx_desc_handler(virtio_snd_state_t *vsnd,
     /* TODO: remove this part as we are going to use ring buffer */
     idx = 0;
     virtq_desc_queue_node_t *tmp = NULL;
-    queue_for_each_entry_safe(node, tmp, &q, q)
-    {
-        queue_del(&node->q);
+    list_for_each_entry_safe (node, tmp, &q, q) {
+        list_del(&node->q);
         free(node);
         idx++;
     }