Changes in uspace/srv/fs/mfs/mfs_ops.c [c2e50d7:7a46bfe] in mainline

File:

• uspace/srv/fs/mfs/mfs_ops.c (modified) (53 diffs)

uspace/srv/fs/mfs/mfs_ops.c

@@ -43 +43 @@
 
 static bool check_magic_number(uint16_t magic, bool *native,
-    mfs_version_t *version, bool *longfilenames);
+                               mfs_version_t *version, bool *longfilenames);
 static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
-    fs_index_t index);
+                             fs_index_t index);
+
 static int mfs_node_put(fs_node_t *fsnode);
 static int mfs_node_open(fs_node_t *fsnode);
@@ -54 +55 @@
 static int mfs_has_children(bool *has_children, fs_node_t *fsnode);
 static int mfs_root_get(fs_node_t **rfn, service_id_t service_id);
-static service_id_t mfs_service_get(fs_node_t *fsnode);
+static service_id_t mfs_device_get(fs_node_t *fsnode);
 static aoff64_t mfs_size_get(fs_node_t *node);
 static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component);
@@ -63 +64 @@
 static hash_index_t open_nodes_hash(unsigned long key[]);
 static int open_nodes_compare(unsigned long key[], hash_count_t keys,
-    link_t *item);
+                link_t *item);
 static void open_nodes_remove_cb(link_t *link);
+
 static int mfs_node_get(fs_node_t **rfn, service_id_t service_id,
-    fs_index_t index);
-static int mfs_instance_get(service_id_t service_id,
-    struct mfs_instance **instance);
-static int mfs_check_sanity(struct mfs_sb_info *sbi);
-static bool is_power_of_two(uint32_t n);
-
+                        fs_index_t index);
+static int
+mfs_instance_get(service_id_t service_id, struct mfs_instance **instance);
+
+
+static LIST_INITIALIZE(inst_list);
+static FIBRIL_MUTEX_INITIALIZE(inst_list_mutex);
 static hash_table_t open_nodes;
 static FIBRIL_MUTEX_INITIALIZE(open_nodes_lock);
@@ -78 +81 @@
         .size_get = mfs_size_get,
         .root_get = mfs_root_get,
-        .service_get = mfs_service_get,
+        .device_get = mfs_device_get,
         .is_directory = mfs_is_directory,
         .is_file = mfs_is_file,
@@ -95 +98 @@
 
 /* Hash table interface for open nodes hash table */
-static hash_index_t
-open_nodes_hash(unsigned long key[])
+static hash_index_t open_nodes_hash(unsigned long key[])
 {
         /* TODO: This is very simple and probably can be improved */
@@ -102 +104 @@
 }
 
-static int
-open_nodes_compare(unsigned long key[], hash_count_t keys,
-    link_t *item)
+static int open_nodes_compare(unsigned long key[], hash_count_t keys,
+                link_t *item)
 {
         struct mfs_node *mnode = hash_table_get_instance(item, struct mfs_node, link);
@@ -119 +120 @@
 }
 
-static void
-open_nodes_remove_cb(link_t *link)
+static void open_nodes_remove_cb(link_t *link)
 {
         /* We don't use remove callback for this hash table */
@@ -131 +131 @@
 };
 
-int
-mfs_global_init(void)
+int mfs_global_init(void)
 {
         if (!hash_table_create(&open_nodes, OPEN_NODES_BUCKETS,
-            OPEN_NODES_KEYS, &open_nodes_ops)) {
+                        OPEN_NODES_KEYS, &open_nodes_ops)) {
                 return ENOMEM;
         }
@@ -143 +142 @@
 static int
 mfs_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
-    aoff64_t *size, unsigned *linkcnt)
+                aoff64_t *size, unsigned *linkcnt)
 {
         enum cache_mode cmode;
-        struct mfs_superblock *sb = NULL;
-        struct mfs3_superblock *sb3 = NULL;
-        struct mfs_sb_info *sbi = NULL;
-        struct mfs_instance *instance = NULL;
+        struct mfs_superblock *sb;
+        struct mfs3_superblock *sb3;
+        struct mfs_sb_info *sbi;
+        struct mfs_instance *instance;
         bool native, longnames;
         mfs_version_t version;
@@ -166 +165 @@
                 return rc;
 
-        /* Allocate space for generic MFS superblock */
+        /*Allocate space for generic MFS superblock*/
         sbi = malloc(sizeof(*sbi));
         if (!sbi) {
-                rc = ENOMEM;
-                goto out_error;
-        }
-
-        /* Allocate space for filesystem instance */
+                block_fini(service_id);
+                return ENOMEM;
+        }
+
+        /*Allocate space for filesystem instance*/
         instance = malloc(sizeof(*instance));
         if (!instance) {
-                rc = ENOMEM;
-                goto out_error;
-        }
+                free(sbi);
+                block_fini(service_id);
+                return ENOMEM;
+        }
+
+        instance->open_nodes_cnt = 0;
 
         sb = malloc(MFS_SUPERBLOCK_SIZE);
         if (!sb) {
-                rc = ENOMEM;
-                goto out_error;
+                free(instance);
+                free(sbi);
+                block_fini(service_id);
+                return ENOMEM;
         }
 
         /* Read the superblock */
         rc = block_read_direct(service_id, MFS_SUPERBLOCK << 1, 2, sb);
-        if (rc != EOK)
-                goto out_error;
+        if (rc != EOK) {
+                free(instance);
+                free(sbi);
+                free(sb);
+                block_fini(service_id);
+                return rc;
+        }
 
         sb3 = (struct mfs3_superblock *) sb;
 
         if (check_magic_number(sb->s_magic, &native, &version, &longnames)) {
-                /* This is a V1 or V2 Minix filesystem */
+                /*This is a V1 or V2 Minix filesystem*/
                 magic = sb->s_magic;
         } else if (check_magic_number(sb3->s_magic, &native, &version, &longnames)) {
-                /* This is a V3 Minix filesystem */
+                /*This is a V3 Minix filesystem*/
                 magic = sb3->s_magic;
         } else {
-                /* Not recognized */
+                /*Not recognized*/
                 mfsdebug("magic number not recognized\n");
-                rc = ENOTSUP;
-                goto out_error;
+                free(instance);
+                free(sbi);
+                free(sb);
+                block_fini(service_id);
+                return ENOTSUP;
         }
 
         mfsdebug("magic number recognized = %04x\n", magic);
 
-        /* Fill superblock info structure */
+        /*Fill superblock info structure*/
 
         sbi->fs_version = version;
@@ -246 +258 @@
                 sbi->dirsize = longnames ? MFSL_DIRSIZE : MFS_DIRSIZE;
                 sbi->max_name_len = longnames ? MFS_L_MAX_NAME_LEN :
-                    MFS_MAX_NAME_LEN;
-        }
-
-        if (sbi->log2_zone_size != 0) {
-                /* In MFS, file space is allocated per zones.
-                 * Zones are a collection of consecutive blocks on disk.
-                 *
-                 * The current MFS implementation supports only filesystems
-                 * where the size of a zone is equal to the
-                 * size of a block.
-                 */
-                rc = ENOTSUP;
-                goto out_error;
-        }
-
+                                    MFS_MAX_NAME_LEN;
+        }
         sbi->itable_off = 2 + sbi->ibmap_blocks + sbi->zbmap_blocks;
-        if ((rc = mfs_check_sanity(sbi)) != EOK) {
-                fprintf(stderr, "Filesystem corrupted, invalid superblock");
-                goto out_error;
-        }
+
+        free(sb);
 
         rc = block_cache_init(service_id, sbi->block_size, 0, cmode);
         if (rc != EOK) {
+                free(instance);
+                free(sbi);
+                free(sb);
+                block_cache_fini(service_id);
+                block_fini(service_id);
                 mfsdebug("block cache initialization failed\n");
-                rc = EINVAL;
-                goto out_error;
-        }
-
-        /* Initialize the instance structure and remember it */
+                return EINVAL;
+        }
+
+        /*Initialize the instance structure and add it to the list*/
+        link_initialize(&instance->link);
         instance->service_id = service_id;
         instance->sbi = sbi;
-        instance->open_nodes_cnt = 0;
-        rc = fs_instance_create(service_id, instance);
-        if (rc != EOK) {
-                block_cache_fini(service_id);
-                mfsdebug("fs instance creation failed\n");
-                goto out_error;
-        }
+
+        fibril_mutex_lock(&inst_list_mutex);
+        list_append(&instance->link, &inst_list);
+        fibril_mutex_unlock(&inst_list_mutex);
 
         mfsdebug("mount successful\n");
@@ -296 +295 @@
         *linkcnt = 1;
 
-        free(sb);
-
         return mfs_node_put(fn);
-
-out_error:
-        block_fini(service_id);
-        if (sb)
-                free(sb);
-        if (sbi)
-                free(sbi);
-        if(instance)
-                free(instance);
-        return rc;
 }
 
@@ -328 +315 @@
         block_fini(service_id);
 
-        /* Remove and destroy the instance */
-        (void) fs_instance_destroy(service_id);
+        /* Remove the instance from the list */
+        fibril_mutex_lock(&inst_list_mutex);
+        list_remove(&inst->link);
+        fibril_mutex_unlock(&inst_list_mutex);
+
         free(inst->sbi);
         free(inst);
@@ -335 +325 @@
 }
 
-service_id_t
-mfs_service_get(fs_node_t *fsnode)
+service_id_t mfs_device_get(fs_node_t *fsnode)
 {
         struct mfs_node *node = fsnode->data;
@@ -342 +331 @@
 }
 
-static int
-mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
+static int mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
 {
         int r;
@@ -357 +345 @@
                 return r;
 
-        /* Alloc a new inode */
+        /*Alloc a new inode*/
         r = mfs_alloc_inode(inst, &inum);
         if (r != EOK)
@@ -384 +372 @@
         if (flags & L_DIRECTORY) {
                 ino_i->i_mode = S_IFDIR;
-                ino_i->i_nlinks = 1; /* This accounts for the '.' dentry */
-        } else
+                ino_i->i_nlinks = 2; /*This accounts for the '.' dentry*/
+        } else {
                 ino_i->i_mode = S_IFREG;
+                ino_i->i_nlinks = 1;
+        }
 
         ino_i->i_uid = 0;
@@ -435 +425 @@
 }
 
-static int
-mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
+static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
 {
         struct mfs_node *mnode = pfn->data;
@@ -458 +447 @@
 
                 if (!d_info.d_inum) {
-                        /* This entry is not used */
+                        /*This entry is not used*/
                         continue;
                 }
@@ -465 +454 @@
 
                 if (comp_size == dentry_name_size &&
-                    !bcmp(component, d_info.d_name, dentry_name_size)) {
-                        /* Hit! */
+                        !bcmp(component, d_info.d_name, dentry_name_size)) {
+                        /*Hit!*/
                         mfs_node_core_get(rfn, mnode->instance,
-                            d_info.d_inum);
+                                          d_info.d_inum);
                         goto found;
                 }
@@ -477 +466 @@
 }
 
-static aoff64_t
-mfs_size_get(fs_node_t *node)
-{
+static aoff64_t mfs_size_get(fs_node_t *node)
+{
+        assert(node);
+
         const struct mfs_node *mnode = node->data;
+        assert(mnode);
+        assert(mnode->ino_i);
+
         return mnode->ino_i->i_size;
 }
@@ -486 +479 @@
 static int
 mfs_node_get(fs_node_t **rfn, service_id_t service_id,
-    fs_index_t index)
+                        fs_index_t index)
 {
         int rc;
@@ -520 +513 @@
                 assert(mnode->instance->open_nodes_cnt > 0);
                 mnode->instance->open_nodes_cnt--;
-                rc = mfs_put_inode(mnode);
+                rc = mfs_put_inode_core(mnode);
                 free(mnode->ino_i);
                 free(mnode);
@@ -530 +523 @@
 }
 
-static int
-mfs_node_open(fs_node_t *fsnode)
+static int mfs_node_open(fs_node_t *fsnode)
 {
         /*
@@ -540 +532 @@
 }
 
-static fs_index_t
-mfs_index_get(fs_node_t *fsnode)
+static fs_index_t mfs_index_get(fs_node_t *fsnode)
 {
         struct mfs_node *mnode = fsnode->data;
+
+        assert(mnode->ino_i);
         return mnode->ino_i->index;
 }
 
-static unsigned
-mfs_lnkcnt_get(fs_node_t *fsnode)
+static unsigned mfs_lnkcnt_get(fs_node_t *fsnode)
 {
         struct mfs_node *mnode = fsnode->data;
@@ -563 +555 @@
 }
 
-static int
-mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
-    fs_index_t index)
+static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
+                             fs_index_t index)
 {
         fs_node_t *node = NULL;
@@ -637 +628 @@
 }
 
-static bool
-mfs_is_directory(fs_node_t *fsnode)
+static bool mfs_is_directory(fs_node_t *fsnode)
 {
         const struct mfs_node *node = fsnode->data;
@@ -644 +634 @@
 }
 
-static bool
-mfs_is_file(fs_node_t *fsnode)
+static bool mfs_is_file(fs_node_t *fsnode)
 {
         struct mfs_node *node = fsnode->data;
@@ -651 +640 @@
 }
 
-static int
-mfs_root_get(fs_node_t **rfn, service_id_t service_id)
+static int mfs_root_get(fs_node_t **rfn, service_id_t service_id)
 {
         int rc = mfs_node_get(rfn, service_id, MFS_ROOT_INO);
@@ -658 +646 @@
 }
 
-static int
-mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
+static int mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
 {
         struct mfs_node *parent = pfn->data;
         struct mfs_node *child = cfn->data;
         struct mfs_sb_info *sbi = parent->instance->sbi;
-        bool destroy_dentry = false;
 
         mfsdebug("%s()\n", __FUNCTION__);
@@ -673 +659 @@
         int r = mfs_insert_dentry(parent, name, child->ino_i->index);
         if (r != EOK)
-                return r;
+                goto exit_error;
 
         if (S_ISDIR(child->ino_i->i_mode)) {
-                if (child->ino_i->i_nlinks != 1) {
-                        /* It's not possible to hardlink directories in MFS */
-                        destroy_dentry = true;
-                        r = EMLINK;
-                        goto exit;
-                }
                 r = mfs_insert_dentry(child, ".", child->ino_i->index);
-                if (r != EOK) {
-                        destroy_dentry = true;
-                        goto exit;
-                }
+                if (r != EOK)
+                        goto exit_error;
 
                 r = mfs_insert_dentry(child, "..", parent->ino_i->index);
-                if (r != EOK) {
-                        destroy_dentry = true;
-                        goto exit;
-                }
+                if (r != EOK)
+                        goto exit_error;
 
                 parent->ino_i->i_nlinks++;
@@ -698 +674 @@
         }
 
-exit:
-        if (destroy_dentry) {
-                int r2 = mfs_remove_dentry(parent, name);
-                if (r2 != EOK)
-                        r = r2;
-        } else {
-                child->ino_i->i_nlinks++;
-                child->ino_i->dirty = true;
-        }
+exit_error:
         return r;
 }
@@ -753 +721 @@
 }
 
-static int
-mfs_has_children(bool *has_children, fs_node_t *fsnode)
+static int mfs_has_children(bool *has_children, fs_node_t *fsnode)
 {
         struct mfs_node *mnode = fsnode->data;
@@ -775 +742 @@
 
                 if (d_info.d_inum) {
-                        /* A valid entry has been found */
+                        /*A valid entry has been found*/
                         *has_children = true;
                         break;
@@ -787 +754 @@
 static int
 mfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
-    size_t *rbytes)
+                size_t *rbytes)
 {
         int rc;
@@ -817 +784 @@
 
                 if (pos < 2) {
-                        /* Skip the first two dentries ('.' and '..') */
+                        /*Skip the first two dentries ('.' and '..')*/
                         pos = 2;
                 }
@@ -827 +794 @@
 
                         if (d_info.d_inum) {
-                                /* Dentry found! */
+                                /*Dentry found!*/
                                 goto found;
                         }
@@ -837 +804 @@
 found:
                 async_data_read_finalize(callid, d_info.d_name,
-                    str_size(d_info.d_name) + 1);
+                                         str_size(d_info.d_name) + 1);
                 bytes = ((pos - spos) + 1);
         } else {
@@ -843 +810 @@
 
                 if (pos >= (size_t) ino_i->i_size) {
-                        /* Trying to read beyond the end of file */
+                        /*Trying to read beyond the end of file*/
                         bytes = 0;
                         (void) async_data_read_finalize(callid, NULL, 0);
@@ -860 +827 @@
 
                 if (zone == 0) {
-                        /* sparse file */
+                        /*sparse file*/
                         uint8_t *buf = malloc(sbi->block_size);
                         if (!buf) {
@@ -868 +835 @@
                         memset(buf, 0, sizeof(sbi->block_size));
                         async_data_read_finalize(callid,
-                            buf + pos % sbi->block_size, bytes);
+                                                 buf + pos % sbi->block_size, bytes);
                         free(buf);
                         goto out_success;
@@ -878 +845 @@
 
                 async_data_read_finalize(callid, b->data +
-                    pos % sbi->block_size, bytes);
+                                         pos % sbi->block_size, bytes);
 
                 rc = block_put(b);
@@ -899 +866 @@
 static int
 mfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
-    size_t *wbytes, aoff64_t *nsize)
+                size_t *wbytes, aoff64_t *nsize)
 {
         fs_node_t *fn;
@@ -923 +890 @@
         struct mfs_ino_info *ino_i = mnode->ino_i;
         const size_t bs = sbi->block_size;
-        size_t bytes = min(len, bs - (pos % bs));
+        size_t bytes = min(len, bs - pos % bs);
+        size_t boundary = ROUND_UP(ino_i->i_size, bs);
         uint32_t block;
 
@@ -929 +897 @@
                 flags = BLOCK_FLAGS_NOREAD;
 
-        r = mfs_read_map(&block, mnode, pos);
-        if (r != EOK)
-                goto out_err;
-
-        if (block == 0) {
+        if (pos < boundary) {
+                r = mfs_read_map(&block, mnode, pos);
+                if (r != EOK)
+                        goto out_err;
+
+                if (block == 0) {
+                        /*Writing in a sparse block*/
+                        r = mfs_alloc_zone(mnode->instance, &block);
+                        if (r != EOK)
+                                goto out_err;
+                        flags = BLOCK_FLAGS_NOREAD;
+                }
+        } else {
                 uint32_t dummy;
 
@@ -939 +915 @@
                 if (r != EOK)
                         goto out_err;
-                
+
                 r = mfs_write_map(mnode, pos, block, &dummy);
                 if (r != EOK)
                         goto out_err;
-
-                flags = BLOCK_FLAGS_NOREAD;
         }
 
@@ -952 +926 @@
                 goto out_err;
 
-        if (flags == BLOCK_FLAGS_NOREAD)
-                memset(b->data, 0, sbi->block_size);
-
-        async_data_write_finalize(callid, b->data + (pos % bs), bytes);
+        async_data_write_finalize(callid, b->data + pos % bs, bytes);
         b->dirty = true;
 
@@ -964 +935 @@
         }
 
-        if (pos + bytes > ino_i->i_size) {
-                ino_i->i_size = pos + bytes;
-                ino_i->dirty = true;
-        }
+        ino_i->i_size = pos + bytes;
+        ino_i->dirty = true;
         r = mfs_node_put(fn);
-        *nsize = ino_i->i_size;
+        *nsize = pos + bytes;
         *wbytes = bytes;
         return r;
@@ -991 +960 @@
                 return ENOENT;
 
-        /* Destroy the inode */
+        /*Destroy the inode*/
         return mfs_destroy_node(fn);
 }
@@ -1010 +979 @@
         assert(!has_children);
 
-        /* Free the entire inode content */
+        /*Free the entire inode content*/
         r = mfs_inode_shrink(mnode, mnode->ino_i->i_size);
         if (r != EOK)
                 goto out;
 
-        /* Mark the inode as free in the bitmap */
+        /*Mark the inode as free in the bitmap*/
         r = mfs_free_inode(mnode->instance, mnode->ino_i->index);
 
@@ -1050 +1019 @@
 mfs_instance_get(service_id_t service_id, struct mfs_instance **instance)
 {
-        void *data;
-        int rc;
-
-        rc = fs_instance_get(service_id, &data);
-        if (rc == EOK)
-                *instance = (struct mfs_instance *) data;
-        else {
-                mfsdebug("instance not found\n");
-        }
-
-        return rc;
-}
-
-static bool
-check_magic_number(uint16_t magic, bool *native,
-                mfs_version_t *version, bool *longfilenames)
+        struct mfs_instance *instance_ptr;
+
+        fibril_mutex_lock(&inst_list_mutex);
+
+        if (list_empty(&inst_list)) {
+                fibril_mutex_unlock(&inst_list_mutex);
+                return EINVAL;
+        }
+
+        list_foreach(inst_list, link) {
+                instance_ptr = list_get_instance(link, struct mfs_instance,
+                                                 link);
+
+                if (instance_ptr->service_id == service_id) {
+                        *instance = instance_ptr;
+                        fibril_mutex_unlock(&inst_list_mutex);
+                        return EOK;
+                }
+        }
+
+        mfsdebug("Instance not found\n");
+
+        fibril_mutex_unlock(&inst_list_mutex);
+        return EINVAL;
+}
+
+static bool check_magic_number(uint16_t magic, bool *native,
+                               mfs_version_t *version, bool *longfilenames)
 {
         bool rc = true;
@@ -1093 +1074 @@
 }
 
-/** Filesystem sanity check
- *
- * @param Pointer to the MFS superblock.
- *
- * @return EOK on success, ENOTSUP otherwise.
- */
-static int
-mfs_check_sanity(struct mfs_sb_info *sbi)
-{
-        if (!is_power_of_two(sbi->block_size) ||
-            sbi->block_size < MFS_MIN_BLOCKSIZE ||
-            sbi->block_size > MFS_MAX_BLOCKSIZE)
-                return ENOTSUP;
-        else if (sbi->ibmap_blocks == 0 || sbi->zbmap_blocks == 0)
-                return ENOTSUP;
-        else if (sbi->ninodes == 0 || sbi->nzones == 0)
-                return ENOTSUP;
-        else if (sbi->firstdatazone == 0)
-                return ENOTSUP;
-
-        return EOK;
-}
-
 static int
 mfs_close(service_id_t service_id, fs_index_t index)
@@ -1136 +1094 @@
 
         return mfs_node_put(fn);
-}
-
-/** Check if a given number is a power of two.
- *
- * @param n     The number to check.
- *
- * @return      true if it is a power of two, false otherwise.
- */
-static bool
-is_power_of_two(uint32_t n)
-{
-        if (n == 0)
-                return false;
-
-        return (n & (n - 1)) == 0;
 }