Changeset 9cc1f43 in mainline

Timestamp:

2011-08-03T18:49:28Z (13 years ago)

Author:

Oleg Romanenko <romanenko.oleg@…>

Branches:

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

Children:

f1119e5

Parents:

1940326

Message:

Migrate changes from mainline to exfat_idx.c

File:

• uspace/srv/fs/exfat/exfat_idx.c (modified) (11 diffs)

uspace/srv/fs/exfat/exfat_idx.c

@@ -58 +58 @@
  */
 typedef struct {
-        link_t          link;
-        devmap_handle_t devmap_handle;
+        link_t link;
+        devmap_handle_t devmap_handle;
 
         /** Next unassigned index. */
-        fs_index_t      next;
+        fs_index_t next;
         /** Number of remaining unassigned indices. */
-        uint64_t        remaining;
+        uint64_t remaining;
 
         /** Sorted list of intervals of freed indices. */
-        link_t          freed_head;
+        link_t freed_list;
 } unused_t;
 
@@ -74 +74 @@
 
 /** List of unused structures. */
-static LIST_INITIALIZE(unused_head);
+static LIST_INITIALIZE(unused_list);
 
 static void unused_initialize(unused_t *u, devmap_handle_t devmap_handle)
@@ -82 +82 @@
         u->next = 0;
         u->remaining = ((uint64_t)((fs_index_t)-1)) + 1;
-        list_initialize(&u->freed_head);
+        list_initialize(&u->freed_list);
 }
 
@@ -92 +92 @@
         if (lock)
                 fibril_mutex_lock(&unused_lock);
-        for (l = unused_head.next; l != &unused_head; l = l->next) {
+        list_foreach(unused_list, l) {
                 u = list_get_instance(l, unused_t, link);
                 if (u->devmap_handle == devmap_handle) 
                         return u;
         }
+
         if (lock)
                 fibril_mutex_unlock(&unused_lock);
@@ -249 +250 @@
                 return false;   
 
-        if (list_empty(&u->freed_head)) {
+        if (list_empty(&u->freed_list)) {
                 if (u->remaining) { 
                         /*
@@ -262 +263 @@
         } else {
                 /* There are some freed indices which we can reuse. */
-                freed_t *f = list_get_instance(u->freed_head.next, freed_t,
-                    link);
+                freed_t *f = list_get_instance(list_first(&u->freed_list),
+                    freed_t, link);
                 *index = f->first;
                 if (f->first++ == f->last) {
@@ -320 +321 @@
                 link_t *lnk;
                 freed_t *n;
-                for (lnk = u->freed_head.next; lnk != &u->freed_head;
+                for (lnk = u->freed_list.head.next; lnk != &u->freed_list.head;
                     lnk = lnk->next) {
                         freed_t *f = list_get_instance(lnk, freed_t, link);
                         if (f->first == index + 1) {
                                 f->first--;
-                                if (lnk->prev != &u->freed_head)
+                                if (lnk->prev != &u->freed_list.head)
                                         try_coalesce_intervals(lnk->prev, lnk,
                                             lnk);
@@ -333 +334 @@
                         if (f->last == index - 1) {
                                 f->last++;
-                                if (lnk->next != &u->freed_head)
+                                if (lnk->next != &u->freed_list.head)
                                         try_coalesce_intervals(lnk, lnk->next,
                                             lnk);
@@ -359 +360 @@
                 n->first = index;
                 n->last = index;
-                list_append(&n->link, &u->freed_head);
+                list_append(&n->link, &u->freed_list);
         }
         fibril_mutex_unlock(&unused_lock);
@@ -559 +560 @@
         fibril_mutex_lock(&unused_lock);
         if (!unused_find(devmap_handle, false)) {
-                list_append(&u->link, &unused_head);
+                list_append(&u->link, &unused_list);
         } else {
                 free(u);
@@ -595 +596 @@
         fibril_mutex_unlock(&unused_lock);
 
-        while (!list_empty(&u->freed_head)) {
+        while (!list_empty(&u->freed_list)) {
                 freed_t *f;
-                f = list_get_instance(u->freed_head.next, freed_t, link);
+                f = list_get_instance(list_first(&u->freed_list), freed_t, link);
                 list_remove(&f->link);
                 free(f);