Changeset 2e07f62c in mainline

Timestamp:

2010-01-31T18:11:24Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

1735f3e, 7d6f7d2b

Parents:

ab4bace (diff), 430de97 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge progress from the file system branch allowing FAT to be unmounted.

Location:

uspace

Files:

• lib/libblock/libblock.c (modified) (2 diffs)
• lib/libblock/libblock.h (modified) (1 diff)
• srv/fs/fat/fat_idx.c (modified) (5 diffs)
• srv/fs/fat/fat_ops.c (modified) (7 diffs)

uspace/lib/libblock/libblock.c

@@ -198 +198 @@
         assert(devcon);
         
+        if (devcon->cache)
+                (void) block_cache_fini(dev_handle);
+
         devcon_remove(devcon);
 
         if (devcon->bb_buf)
                 free(devcon->bb_buf);
-
-        if (devcon->cache) {
-                hash_table_destroy(&devcon->cache->block_hash);
-                free(devcon->cache);
-        }
 
         munmap(devcon->comm_area, devcon->comm_size);
@@ -302 +300 @@
 
         devcon->cache = cache;
+        return EOK;
+}
+
+int block_cache_fini(dev_handle_t dev_handle)
+{
+        devcon_t *devcon = devcon_search(dev_handle);
+        cache_t *cache;
+        int rc;
+
+        if (!devcon)
+                return ENOENT;
+        if (!devcon->cache)
+                return EOK;
+        cache = devcon->cache;
+        
+        /*
+         * We are expecting to find all blocks for this device handle on the
+         * free list, i.e. the block reference count should be zero. Do not
+         * bother with the cache and block locks because we are single-threaded.
+         */
+        while (!list_empty(&cache->free_head)) {
+                block_t *b = list_get_instance(cache->free_head.next,
+                    block_t, free_link);
+
+                list_remove(&b->free_link);
+                if (b->dirty) {
+                        memcpy(devcon->comm_area, b->data, b->size);
+                        rc = write_blocks(devcon, b->boff, 1);
+                        if (rc != EOK)
+                                return rc;
+                }
+
+                long key = b->boff;
+                hash_table_remove(&cache->block_hash, &key, 1);
+                
+                free(b->data);
+                free(b);
+        }
+
+        hash_table_destroy(&cache->block_hash);
+        devcon->cache = NULL;
+        free(cache);
+
         return EOK;
 }

uspace/lib/libblock/libblock.h

@@ -100 +100 @@
 
 extern int block_cache_init(dev_handle_t, size_t, unsigned, enum cache_mode);
+extern int block_cache_fini(dev_handle_t);
 
 extern int block_get(block_t **, dev_handle_t, bn_t, int);

uspace/srv/fs/fat/fat_idx.c

@@ -149 +149 @@
 {
         dev_handle_t dev_handle = (dev_handle_t)key[UPH_DH_KEY];
-        fat_cluster_t pfc = (fat_cluster_t)key[UPH_PFC_KEY];
-        unsigned pdi = (unsigned)key[UPH_PDI_KEY];
+        fat_cluster_t pfc;
+        unsigned pdi;
         fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uph_link);
 
-        return (dev_handle == fidx->dev_handle) && (pfc == fidx->pfc) &&
-            (pdi == fidx->pdi);
+        switch (keys) {
+        case 1:
+                return (dev_handle == fidx->dev_handle);
+        case 3:
+                pfc = (fat_cluster_t) key[UPH_PFC_KEY];
+                pdi = (unsigned) key[UPH_PDI_KEY];
+                return (dev_handle == fidx->dev_handle) && (pfc == fidx->pfc) &&
+                    (pdi == fidx->pdi);
+        default:
+                assert((keys == 1) || (keys == 3));
+        }
 }
 
@@ -197 +206 @@
 {
         dev_handle_t dev_handle = (dev_handle_t)key[UIH_DH_KEY];
-        fs_index_t index = (fs_index_t)key[UIH_INDEX_KEY];
+        fs_index_t index;
         fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uih_link);
 
-        return (dev_handle == fidx->dev_handle) && (index == fidx->index);
+        switch (keys) {
+        case 1:
+                return (dev_handle == fidx->dev_handle);
+        case 2:
+                index = (fs_index_t) key[UIH_INDEX_KEY];
+                return (dev_handle == fidx->dev_handle) &&
+                    (index == fidx->index);
+        default:
+                assert((keys == 1) || (keys == 2));
+        }
 }
 
 static void idx_remove_callback(link_t *item)
 {
-        /* nothing to do */
+        fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uih_link);
+
+        free(fidx);
 }
 
@@ -486 +506 @@
                 [UIH_INDEX_KEY] = idx->index,
         };
+        dev_handle_t dev_handle = idx->dev_handle;
+        fs_index_t index = idx->index;
 
         assert(idx->pfc == FAT_CLST_RES0);
@@ -498 +520 @@
         fibril_mutex_unlock(&used_lock);
         /* Release the VFS index. */
-        fat_index_free(idx->dev_handle, idx->index);
-        /* Deallocate the structure. */
-        free(idx);
+        fat_index_free(dev_handle, index);
+        /* The index structure itself is freed in idx_remove_callback(). */
 }
 
@@ -543 +564 @@
 void fat_idx_fini_by_dev_handle(dev_handle_t dev_handle)
 {
-        unused_t *u;
-
-        u = unused_find(dev_handle, true);
+        unsigned long ikey[] = {
+                [UIH_DH_KEY] = dev_handle
+        };
+        unsigned long pkey[] = {
+                [UPH_DH_KEY] = dev_handle
+        };
+
+        /*
+         * Remove this instance's index structure from up_hash and ui_hash.
+         * Process up_hash first and ui_hash second because the index structure
+         * is actually removed in idx_remove_callback(). 
+         */
+        fibril_mutex_lock(&used_lock);
+        hash_table_remove(&up_hash, pkey, 1);
+        hash_table_remove(&ui_hash, ikey, 1);
+        fibril_mutex_unlock(&used_lock);
+
+        /*
+         * Free the unused and freed structures for this instance.
+         */
+        unused_t *u = unused_find(dev_handle, true);
         assert(u);
         list_remove(&u->link);

uspace/srv/fs/fat/fat_ops.c

@@ -137 +137 @@
         rc = block_put(b);
         return rc;
+}
+
+static int fat_node_fini_by_dev_handle(dev_handle_t dev_handle)
+{
+        link_t *lnk;
+        fat_node_t *nodep;
+        int rc;
+
+        /*
+         * We are called from fat_unmounted() and assume that there are already
+         * no nodes belonging to this instance with non-zero refcount. Therefore
+         * it is sufficient to clean up only the FAT free node list.
+         */
+
+restart:
+        fibril_mutex_lock(&ffn_mutex);
+        for (lnk = ffn_head.next; lnk != &ffn_head; lnk = lnk->next) {
+                nodep = list_get_instance(lnk, fat_node_t, ffn_link);
+                if (!fibril_mutex_trylock(&nodep->lock)) {
+                        fibril_mutex_unlock(&ffn_mutex);
+                        goto restart;
+                }
+                if (!fibril_mutex_trylock(&nodep->idx->lock)) {
+                        fibril_mutex_unlock(&nodep->lock);
+                        fibril_mutex_unlock(&ffn_mutex);
+                        goto restart;
+                }
+                if (nodep->idx->dev_handle != dev_handle) {
+                        fibril_mutex_unlock(&nodep->idx->lock);
+                        fibril_mutex_unlock(&nodep->lock);
+                        continue;
+                }
+
+                list_remove(&nodep->ffn_link);
+                fibril_mutex_unlock(&ffn_mutex);
+
+                /*
+                 * We can unlock the node and its index structure because we are
+                 * the last player on this playground and VFS is preventing new
+                 * players from entering.
+                 */
+                fibril_mutex_unlock(&nodep->idx->lock);
+                fibril_mutex_unlock(&nodep->lock);
+
+                if (nodep->dirty) {
+                        rc = fat_node_sync(nodep);
+                        if (rc != EOK)
+                                return rc;
+                }
+                nodep->idx->nodep = NULL;
+                free(nodep->bp);
+                free(nodep);
+
+                /* Need to restart because we changed the ffn_head list. */
+                goto restart;
+        }
+        fibril_mutex_unlock(&ffn_mutex);
+
+        return EOK;
 }
 
@@ -986 +1045 @@
         rc = fat_sanity_check(bs, dev_handle);
         if (rc != EOK) {
+                (void) block_cache_fini(dev_handle);
                 block_fini(dev_handle);
                 ipc_answer_0(rid, rc);
@@ -993 +1053 @@
         rc = fat_idx_init_by_dev_handle(dev_handle);
         if (rc != EOK) {
+                (void) block_cache_fini(dev_handle);
                 block_fini(dev_handle);
                 ipc_answer_0(rid, rc);
@@ -1001 +1062 @@
         fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
         if (!rfn) {
+                (void) block_cache_fini(dev_handle);
                 block_fini(dev_handle);
                 fat_idx_fini_by_dev_handle(dev_handle);
@@ -1010 +1072 @@
         if (!rootp) {
                 free(rfn);
+                (void) block_cache_fini(dev_handle);
                 block_fini(dev_handle);
                 fat_idx_fini_by_dev_handle(dev_handle);
@@ -1021 +1084 @@
                 free(rfn);
                 free(rootp);
+                (void) block_cache_fini(dev_handle);
                 block_fini(dev_handle);
                 fat_idx_fini_by_dev_handle(dev_handle);
@@ -1051 +1115 @@
 void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
 {
-        ipc_answer_0(rid, ENOTSUP);
+        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        fs_node_t *fn;
+        fat_node_t *nodep;
+        int rc;
+
+        rc = fat_root_get(&fn, dev_handle);
+        if (rc != EOK) {
+                ipc_answer_0(rid, rc);
+                return;
+        }
+        nodep = FAT_NODE(fn);
+
+        /*
+         * We expect exactly two references on the root node. One for the
+         * fat_root_get() above and one created in fat_mounted().
+         */
+        if (nodep->refcnt != 2) {
+                (void) fat_node_put(fn);
+                ipc_answer_0(rid, EBUSY);
+                return;
+        }
+        
+        /*
+         * Put the root node and force it to the FAT free node list.
+         */
+        (void) fat_node_put(fn);
+        (void) fat_node_put(fn);
+
+        /*
+         * Perform cleanup of the node structures, index structures and
+         * associated data. Write back this file system's dirty blocks and
+         * stop using libblock for this instance.
+         */
+        (void) fat_node_fini_by_dev_handle(dev_handle);
+        fat_idx_fini_by_dev_handle(dev_handle);
+        (void) block_cache_fini(dev_handle);
+        block_fini(dev_handle);
+
+        ipc_answer_0(rid, EOK);
 }