Changeset 583c2a3 in mainline

Timestamp:

2020-07-06T22:58:19Z (4 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

37d4c91, ee2f0beb

Parents:

762f989

Message:

Avoid most cases of direct used of list_t.prev/next in kernel

Location:

kernel/generic/src

Files:

• console/kconsole.c (modified) (2 diffs)
• mm/slab.c (modified) (1 diff)
• proc/scheduler.c (modified) (2 diffs)
• time/timeout.c (modified) (4 diffs)

kernel/generic/src/console/kconsole.c

@@ -172 +172 @@
 
         if (*startpos == NULL)
-                *startpos = cmd_list.head.next;
-
-        for (; *startpos != &cmd_list.head; *startpos = (*startpos)->next) {
+                *startpos = list_first(&cmd_list);
+
+        for (; *startpos != NULL; *startpos = list_next(*startpos, &cmd_list)) {
                 cmd_info_t *hlp = list_get_instance(*startpos, cmd_info_t, link);
 
@@ -182 +182 @@
 
                 if (str_lcmp(curname, name, namelen) == 0) {
-                        *startpos = (*startpos)->next;
+                        *startpos = list_next(*startpos, &cmd_list);
                         if (h)
                                 *h = hlp->description;

kernel/generic/src/mm/slab.c

@@ -837 +837 @@
                 irq_spinlock_lock(&slab_cache_lock, true);
 
-                link_t *cur = slab_cache_list.head.next;
+                link_t *cur = list_first(&slab_cache_list);
                 size_t i = 0;
-                while (i < skip && cur != &slab_cache_list.head) {
+                while (i < skip && cur != NULL) {
                         i++;
-                        cur = cur->next;
+                        cur = list_next(cur, &slab_cache_list);
                 }
 
-                if (cur == &slab_cache_list.head) {
+                if (cur == NULL) {
                         irq_spinlock_unlock(&slab_cache_lock, true);
                         break;

kernel/generic/src/proc/scheduler.c

@@ -610 +610 @@
 
                         /* Search rq from the back */
-                        link_t *link = cpu->rq[rq].rq.head.prev;
-
-                        while (link != &(cpu->rq[rq].rq.head)) {
+                        link_t *link = list_last(&cpu->rq[rq].rq);
+
+                        while (link != NULL) {
                                 thread = (thread_t *) list_get_instance(link,
                                     thread_t, rq_link);
@@ -644 +644 @@
                                 irq_spinlock_unlock(&thread->lock, false);
 
-                                link = link->prev;
+                                link = list_prev(link, &cpu->rq[rq].rq);
                                 thread = NULL;
                         }

kernel/generic/src/time/timeout.c

@@ -118 +118 @@
         uint64_t sum = 0;
         timeout_t *target = NULL;
-        link_t *cur;
-        for (cur = CPU->timeout_active_list.head.next;
-            cur != &CPU->timeout_active_list.head; cur = cur->next) {
+        link_t *cur, *prev;
+        prev = NULL;
+        for (cur = list_first(&CPU->timeout_active_list);
+            cur != NULL; cur = list_next(cur, &CPU->timeout_active_list)) {
                 target = list_get_instance(cur, timeout_t, link);
                 irq_spinlock_lock(&target->lock, false);
@@ -131 +132 @@
                 sum += target->ticks;
                 irq_spinlock_unlock(&target->lock, false);
-        }
-
-        /* Avoid using cur->prev directly */
-        link_t *prev = cur->prev;
-        list_insert_after(&timeout->link, prev);
+                prev = cur;
+        }
+
+        if (prev == NULL)
+                list_prepend(&timeout->link, &CPU->timeout_active_list);
+        else
+                list_insert_after(&timeout->link, prev);
 
         /*
@@ -146 +149 @@
          * Decrease ticks of timeout's immediate succesor by timeout->ticks.
          */
-        if (cur != &CPU->timeout_active_list.head) {
+        if (cur != NULL) {
                 irq_spinlock_lock(&target->lock, false);
                 target->ticks -= timeout->ticks;
@@ -187 +190 @@
          */
 
-        link_t *cur = timeout->link.next;
-        if (cur != &timeout->cpu->timeout_active_list.head) {
+        link_t *cur = list_next(&timeout->link,
+            &timeout->cpu->timeout_active_list);
+        if (cur != NULL) {
                 timeout_t *tmp = list_get_instance(cur, timeout_t, link);
                 irq_spinlock_lock(&tmp->lock, false);