Changeset b72efe8 in mainline for uspace/srv/fs

Timestamp:

2011-06-19T14:38:59Z (14 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

74464e8

Parents:

1d1bb0f

Message:

Separate list_t typedef from link_t (user-space part).

• list_t represents lists
• Use list_first(), list_last(), list_empty() where appropriate
• Use list_foreach() where possible
• assert_link_not_used()
• usb_hid_report_path_free() shall not unlink the path, caller must do it

Location:

uspace/srv/fs

Files:

• ext2fs/ext2fs_ops.c (modified) (2 diffs)
• fat/fat_idx.c (modified) (11 diffs)
• fat/fat_ops.c (modified) (6 diffs)
• tmpfs/tmpfs.h (modified) (1 diff)
• tmpfs/tmpfs_ops.c (modified) (12 diffs)

uspace/srv/fs/ext2fs/ext2fs_ops.c

@@ -187 +187 @@
 {
         EXT2FS_DBG("(%" PRIun ", -)", devmap_handle);
-        link_t *link;
         ext2fs_instance_t *tmp;
         
@@ -198 +197 @@
         }
 
-        for (link = instance_list.next; link != &instance_list; link = link->next) {
+        list_foreach(instance_list, link) {
                 tmp = list_get_instance(link, ext2fs_instance_t, link);
                 

uspace/srv/fs/fat/fat_idx.c

@@ -67 +67 @@
 
         /** Sorted list of intervals of freed indices. */
-        link_t          freed_head;
+        list_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);
 }
 
@@ -88 +88 @@
 {
         unused_t *u;
-        link_t *l;
 
         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);
@@ -558 +559 @@
         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);
@@ -594 +595 @@
         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);

uspace/srv/fs/fat/fat_ops.c

@@ -67 +67 @@
 
 /** List of cached free FAT nodes. */
-static LIST_INITIALIZE(ffn_head);
+static LIST_INITIALIZE(ffn_list);
 
 /*
@@ -147 +147 @@
 static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
 {
-        link_t *lnk;
         fat_node_t *nodep;
         int rc;
@@ -159 +158 @@
 restart:
         fibril_mutex_lock(&ffn_mutex);
-        for (lnk = ffn_head.next; lnk != &ffn_head; lnk = lnk->next) {
+        list_foreach(ffn_list, lnk) {
                 nodep = list_get_instance(lnk, fat_node_t, ffn_link);
                 if (!fibril_mutex_trylock(&nodep->lock)) {
@@ -196 +195 @@
                 free(nodep);
 
-                /* Need to restart because we changed the ffn_head list. */
+                /* Need to restart because we changed ffn_list. */
                 goto restart;
         }
@@ -211 +210 @@
 
         fibril_mutex_lock(&ffn_mutex);
-        if (!list_empty(&ffn_head)) {
+        if (!list_empty(&ffn_list)) {
                 /* Try to use a cached free node structure. */
                 fat_idx_t *idxp_tmp;
-                nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
+                nodep = list_get_instance(list_first(&ffn_list), fat_node_t,
+                    ffn_link);
                 if (!fibril_mutex_trylock(&nodep->lock))
                         goto skip_cache;
@@ -473 +473 @@
                 if (nodep->idx) {
                         fibril_mutex_lock(&ffn_mutex);
-                        list_append(&nodep->ffn_link, &ffn_head);
+                        list_append(&nodep->ffn_link, &ffn_list);
                         fibril_mutex_unlock(&ffn_mutex);
                 } else {

uspace/srv/fs/tmpfs/tmpfs.h

@@ -67 +67 @@
         size_t size;            /**< File size if type is TMPFS_FILE. */
         void *data;             /**< File content's if type is TMPFS_FILE. */
-        link_t cs_head;         /**< Head of child's siblings list. */
+        list_t cs_list;         /**< Child's siblings list. */
 } tmpfs_node_t;
 

uspace/srv/fs/tmpfs/tmpfs_ops.c

@@ -85 +85 @@
 static int tmpfs_has_children(bool *has_children, fs_node_t *fn)
 {
-        *has_children = !list_empty(&TMPFS_NODE(fn)->cs_head);
+        *has_children = !list_empty(&TMPFS_NODE(fn)->cs_list);
         return EOK;
 }
@@ -180 +180 @@
             nh_link);
 
-        while (!list_empty(&nodep->cs_head)) {
-                tmpfs_dentry_t *dentryp = list_get_instance(nodep->cs_head.next,
-                    tmpfs_dentry_t, link);
+        while (!list_empty(&nodep->cs_list)) {
+                tmpfs_dentry_t *dentryp = list_get_instance(
+                    list_first(&nodep->cs_list), tmpfs_dentry_t, link);
 
                 assert(nodep->type == TMPFS_DIRECTORY);
@@ -214 +214 @@
         nodep->data = NULL;
         link_initialize(&nodep->nh_link);
-        list_initialize(&nodep->cs_head);
+        list_initialize(&nodep->cs_list);
 }
 
@@ -262 +262 @@
 {
         tmpfs_node_t *parentp = TMPFS_NODE(pfn);
-        link_t *lnk;
-
-        for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
-            lnk = lnk->next) {
+
+        list_foreach(parentp->cs_list, lnk) {
                 tmpfs_dentry_t *dentryp;
                 dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
@@ -353 +351 @@
         
         assert(!nodep->lnkcnt);
-        assert(list_empty(&nodep->cs_head));
+        assert(list_empty(&nodep->cs_list));
 
         unsigned long key[] = {
@@ -373 +371 @@
         tmpfs_node_t *childp = TMPFS_NODE(cfn);
         tmpfs_dentry_t *dentryp;
-        link_t *lnk;
 
         assert(parentp->type == TMPFS_DIRECTORY);
 
         /* Check for duplicit entries. */
-        for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
-            lnk = lnk->next) {
+        list_foreach(parentp->cs_list, lnk) {
                 dentryp = list_get_instance(lnk, tmpfs_dentry_t, link); 
                 if (!str_cmp(dentryp->name, nm))
@@ -401 +397 @@
         dentryp->node = childp;
         childp->lnkcnt++;
-        list_append(&dentryp->link, &parentp->cs_head);
+        list_append(&dentryp->link, &parentp->cs_list);
 
         return EOK;
@@ -411 +407 @@
         tmpfs_node_t *childp = NULL;
         tmpfs_dentry_t *dentryp;
-        link_t *lnk;
 
         if (!parentp)
                 return EBUSY;
         
-        for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
-            lnk = lnk->next) {
+        list_foreach(parentp->cs_list, lnk) {
                 dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
                 if (!str_cmp(dentryp->name, nm)) {
@@ -423 +417 @@
                         assert(FS_NODE(childp) == cfn);
                         break;
-                }       
+                }
         }
 
@@ -429 +423 @@
                 return ENOENT;
                 
-        if ((childp->lnkcnt == 1) && !list_empty(&childp->cs_head))
+        if ((childp->lnkcnt == 1) && !list_empty(&childp->cs_list))
                 return ENOTEMPTY;
 
@@ -550 +544 @@
                 tmpfs_dentry_t *dentryp;
                 link_t *lnk;
-                aoff64_t i;
                 
                 assert(nodep->type == TMPFS_DIRECTORY);
@@ -559 +552 @@
                  * hash table.
                  */
-                for (i = 0, lnk = nodep->cs_head.next;
-                    (i < pos) && (lnk != &nodep->cs_head);
-                    i++, lnk = lnk->next)
-                        ;
-
-                if (lnk == &nodep->cs_head) {
+                lnk = list_nth(&nodep->cs_list, pos);
+                
+                if (lnk == NULL) {
                         async_answer_0(callid, ENOENT);
                         async_answer_1(rid, ENOENT, 0);