Changeset f959a20f in mainline for uspace/lib

Timestamp:

2019-02-01T22:32:38Z (7 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Children:

00b7fc8

Parents:

1a37496

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2019-02-01 21:22:39)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2019-02-01 22:32:38)

Message:

Avoid directly using .head/.next/.prev of list_t/link_t

Use existing constructs from <adt/list.h> instead.

Location:

uspace/lib

Files:

• c/generic/adt/hash_table.c (modified) (1 diff)
• c/generic/thread/fibril.c (modified) (1 diff)
• c/include/ipc/devman.h (modified) (1 diff)
• nic/include/nic.h (modified) (1 diff)
• nic/src/nic_driver.c (modified) (5 diffs)
• posix/src/signal.c (modified) (1 diff)
• usbhid/src/hiddescriptor.c (modified) (3 diffs)
• usbhid/src/hidparser.c (modified) (4 diffs)
• usbhid/src/hidpath.c (modified) (5 diffs)

uspace/lib/c/generic/adt/hash_table.c

@@ -273 +273 @@
 
         size_t idx = h->op->hash(item) % h->bucket_cnt;
+        list_t *list = &h->bucket[idx];
 
         /* Traverse the circular list until we reach the starting item again. */
-        for (link_t *cur = item->link.next; cur != &first->link;
-            cur = cur->next) {
-                assert(cur);
-
-                if (cur == &h->bucket[idx].head)
-                        continue;
+        for (link_t *cur = list_next(&item->link, list); cur != &first->link;
+            cur = list_next(cur, list)) {
+
+                if (!cur)
+                        cur = list_first(list);
 
                 ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);

uspace/lib/c/generic/thread/fibril.c

@@ -601 +601 @@
         assert(timeout);
 
-        link_t *tmp = timeout_list.head.next;
-        while (tmp != &timeout_list.head) {
-                _timeout_t *cur = list_get_instance(tmp, _timeout_t, link);
-
-                if (ts_gteq(&cur->expires, &timeout->expires))
-                        break;
-
-                tmp = tmp->next;
-        }
-
-        list_insert_before(&timeout->link, tmp);
+        list_foreach(timeout_list, link, _timeout_t, cur) {
+                if (ts_gteq(&cur->expires, &timeout->expires)) {
+                        list_insert_before(&timeout->link, &cur->link);
+                        return;
+                }
+        }
+
+        list_append(&timeout->link, &timeout_list);
 }
 

uspace/lib/c/include/ipc/devman.h

@@ -108 +108 @@
 static inline void add_match_id(match_id_list_t *ids, match_id_t *id)
 {
-        match_id_t *mid = NULL;
-        link_t *link = ids->ids.head.next;
-
-        while (link != &ids->ids.head) {
-                mid = list_get_instance(link, match_id_t, link);
+        list_foreach(ids->ids, link, match_id_t, mid) {
                 if (mid->score < id->score) {
-                        break;
+                        list_insert_before(&id->link, &mid->link);
+                        return;
                 }
-                link = link->next;
         }
 
-        list_insert_before(&id->link, link);
+        list_append(&id->link, &ids->ids);
 }
 

uspace/lib/nic/include/nic.h

@@ -71 +71 @@
 } nic_frame_t;
 
-typedef list_t nic_frame_list_t;
+typedef union {
+        list_t list;
+        link_t link;
+} nic_frame_list_t;
 
 /**

uspace/lib/nic/src/nic_driver.c

@@ -329 +329 @@
 
         if (nic_globals.frame_list_cache_size > 0) {
-                frames =
-                    list_get_instance(list_first(&nic_globals.frame_list_cache),
-                    nic_frame_list_t, head);
-                list_remove(&frames->head);
-                list_initialize(frames);
+                frames = list_pop(&nic_globals.frame_list_cache,
+                    nic_frame_list_t, link);
+                assert(frames);
+                list_initialize(&frames->list);
                 nic_globals.frame_list_cache_size--;
                 fibril_mutex_unlock(&nic_globals.lock);
@@ -341 +340 @@
                 frames = malloc(sizeof (nic_frame_list_t));
                 if (frames != NULL)
-                        list_initialize(frames);
+                        list_initialize(&frames->list);
         }
 
@@ -356 +355 @@
                 free(frames);
         } else {
-                list_prepend(&frames->head, &nic_globals.frame_list_cache);
+                list_prepend(&frames->link, &nic_globals.frame_list_cache);
                 nic_globals.frame_list_cache_size++;
                 fibril_mutex_unlock(&nic_globals.lock);
@@ -372 +371 @@
 {
         assert(frame != NULL && frames != NULL);
-        list_append(&frame->link, frames);
+        list_append(&frame->link, &frames->list);
 }
 
@@ -576 +575 @@
         if (frames == NULL)
                 return;
-        while (!list_empty(frames)) {
-                nic_frame_t *frame =
-                    list_get_instance(list_first(frames), nic_frame_t, link);
-
-                list_remove(&frame->link);
+        while (!list_empty(&frames->list)) {
+                nic_frame_t *frame = list_pop(&frames->list, nic_frame_t, link);
                 nic_received_frame(nic_data, frame);
         }

uspace/lib/posix/src/signal.c

@@ -383 +383 @@
 static void _dequeue_unblocked_signals(void)
 {
-        link_t *iterator = _signal_queue.head.next;
-        link_t *next;
-
-        while (iterator != &(_signal_queue).head) {
-                next = iterator->next;
-
+        list_foreach_safe(_signal_queue, cur_link, next_link) {
                 signal_queue_item *item =
-                    list_get_instance(iterator, signal_queue_item, link);
+                    list_get_instance(cur_link, signal_queue_item, link);
 
                 if (!sigismember(&_signal_mask, item->signo) &&
                     _signal_actions[item->signo].sa_handler != SIG_HOLD) {
-                        list_remove(&(item->link));
-                        _raise_sigaction(item->signo, &(item->siginfo));
+                        list_remove(cur_link);
+                        _raise_sigaction(item->signo, &item->siginfo);
                         free(item);
                 }
-
-                iterator = next;
         }
 }

uspace/lib/usbhid/src/hiddescriptor.c

@@ -89 +89 @@
     usb_hid_report_path_t *cmp_path)
 {
-        link_t *path_it = report->collection_paths.head.next;
-        usb_hid_report_path_t *path = NULL;
-
-        if ((report == NULL) || (cmp_path == NULL)) {
+        if (report == NULL || cmp_path == NULL)
                 return NULL;
-        }
-
-        while (path_it != &report->collection_paths.head) {
-                path = list_get_instance(path_it, usb_hid_report_path_t,
-                    cpath_link);
-
+
+        list_foreach(report->collection_paths, cpath_link, usb_hid_report_path_t, path) {
                 if (usb_hid_report_compare_usage_path(path, cmp_path,
-                    USB_HID_PATH_COMPARE_STRICT) == 0) {
-                        break;
-                }
-                path_it = path_it->next;
-        }
-        if (path_it == &report->collection_paths.head) {
-                path = usb_hid_report_path_clone(cmp_path);
-                if (path == NULL) {
-                        return NULL;
-                }
-                list_append(&path->cpath_link, &report->collection_paths);
-                report->collection_paths_count++;
-
-                return path;
-        } else {
-                return list_get_instance(path_it, usb_hid_report_path_t,
-                    cpath_link);
-        }
+                    USB_HID_PATH_COMPARE_STRICT) == 0)
+                        return path;
+        }
+
+        usb_hid_report_path_t *path = usb_hid_report_path_clone(cmp_path);
+        if (path == NULL)
+                return NULL;
+
+        list_append(&path->cpath_link, &report->collection_paths);
+        report->collection_paths_count++;
+
+        return path;
 }
 
@@ -474 +461 @@
                                     usb_hid_report_item_t, link);
 
+                                link_t *tmp_link = list_prev(
+                                    &report_item->usage_path->cpath_link,
+                                    &report->collection_paths);
+                                assert(tmp_link);
+
                                 usb_hid_report_usage_path_t *tmp_usage_path;
-                                tmp_usage_path = list_get_instance(
-                                    report_item->usage_path->cpath_link.prev,
+                                tmp_usage_path = list_get_instance(tmp_link,
                                     usb_hid_report_usage_path_t, rpath_items_link);
 
@@ -486 +477 @@
 
                                 usb_hid_report_path_free(report_item->usage_path);
-                                list_remove (item_link);
+                                list_remove(item_link);
 
                                 break;

uspace/lib/usbhid/src/hidparser.c

@@ -493 +493 @@
 
         if (field == NULL) {
-                field_it = report_des->report_items.head.next;
-        } else {
-                field_it = field->ritems_link.next;
-        }
-
-        while (field_it != &report_des->report_items.head) {
+                field_it = list_first(&report_des->report_items);
+        } else {
+                field_it = list_next(&field->ritems_link, &report_des->report_items);
+        }
+
+        while (field_it != NULL) {
                 field = list_get_instance(field_it, usb_hid_report_field_t,
                     ritems_link);
@@ -514 +514 @@
                         usb_hid_report_remove_last_item(field->collection_path);
                 }
-                field_it = field_it->next;
+                field_it = list_next(field_it, &report_des->report_items);
         }
 
@@ -547 +547 @@
                         return 0;
                 } else {
-                        report_it = report_des->reports_link.next;
+                        report_it = list_next(&report_des->reports_link,
+                            &report->reports);
                 }
         } else {
-                report_it = report->reports.head.next;
-        }
-
-        while (report_it != &report->reports.head) {
+                report_it = list_first(&report->reports);
+        }
+
+        while (report_it != NULL) {
                 report_des = list_get_instance(report_it,
                     usb_hid_report_description_t, reports_link);
@@ -561 +562 @@
                 }
 
-                report_it = report_it->next;
+                report_it = list_next(report_it, &report->reports);
         }
 

uspace/lib/usbhid/src/hidpath.c

@@ -250 +250 @@
                  * Path is prefix of the report_path
                  */
-                report_link = report_path->items.head.next;
-                path_link = path->items.head.next;
-
-                while ((report_link != &report_path->items.head) &&
-                    (path_link != &path->items.head)) {
+                report_link = list_first(&report_path->items);
+                path_link = list_first(&path->items);
+
+                while (report_link != NULL && path_link != NULL) {
 
                         report_item = list_get_instance(report_link,
@@ -268 +267 @@
                                 return 1;
                         } else {
-                                report_link = report_link->next;
-                                path_link = path_link->next;
+                                report_link = list_next(report_link, &report_path->items);
+                                path_link = list_next(path_link, &path->items);
                         }
                 }
 
                 if ((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) &&
-                    (path_link == &path->items.head)) ||
-                    ((report_link == &report_path->items.head) &&
-                    (path_link == &path->items.head))) {
+                    (path_link == NULL)) ||
+                    (report_link == NULL && path_link == NULL)) {
                         return 0;
                 } else {
@@ -287 +285 @@
                  * Path is suffix of report_path
                  */
-                report_link = report_path->items.head.prev;
-                path_link = path->items.head.prev;
+                report_link = list_last(&report_path->items);
+                path_link = list_last(&path->items);
 
                 if (list_empty(&path->items)) {
@@ -294 +292 @@
                 }
 
-                while ((report_link != &report_path->items.head) &&
-                    (path_link != &path->items.head)) {
+                while (report_link != NULL && path_link != NULL) {
                         report_item = list_get_instance(report_link,
                             usb_hid_report_usage_path_t, rpath_items_link);
@@ -308 +305 @@
                                 return 1;
                         } else {
-                                report_link = report_link->prev;
-                                path_link = path_link->prev;
+                                report_link = list_prev(report_link, &report_path->items);
+                                path_link = list_prev(path_link, &path->items);
                         }
                 }
 
-                if (path_link == &path->items.head) {
+                if (path_link == NULL) {
                         return 0;
                 } else {