Changes in / [b3bf143:f1a9e87] in mainline


Ignore:
Location:
uspace
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/fs/libfs.c

    rb3bf143 rf1a9e87  
    877877}
    878878
    879 static FIBRIL_MUTEX_INITIALIZE(instances_mutex);
    880 static LIST_INITIALIZE(instances_list);
    881 
    882 typedef struct {
    883         service_id_t service_id;
    884         link_t link;
    885         void *data;
    886 } fs_instance_t;
    887 
    888 int fs_instance_create(service_id_t service_id, void *data)
    889 {
    890         fs_instance_t *inst = malloc(sizeof(fs_instance_t));
    891         if (!inst)
    892                 return ENOMEM;
    893 
    894         link_initialize(&inst->link);
    895         inst->service_id = service_id;
    896         inst->data = data;
    897 
    898         fibril_mutex_lock(&instances_mutex);
    899         list_foreach(instances_list, link) {
    900                 fs_instance_t *cur = list_get_instance(link, fs_instance_t,
    901                     link);
    902 
    903                 if (cur->service_id == service_id) {
    904                         fibril_mutex_unlock(&instances_mutex);
    905                         free(inst);
    906                         return EEXIST;
    907                 }
    908 
    909                 /* keep the list sorted */
    910                 if (cur->service_id < service_id) {
    911                         list_insert_before(&inst->link, &cur->link);
    912                         fibril_mutex_unlock(&instances_mutex);
    913                         return EOK;
    914                 }
    915         }
    916         list_append(&inst->link, &instances_list);
    917         fibril_mutex_unlock(&instances_mutex);
    918 
    919         return EOK;
    920 }
    921 
    922 int fs_instance_get(service_id_t service_id, void **idp)
    923 {
    924         fibril_mutex_lock(&instances_mutex);
    925         list_foreach(instances_list, link) {
    926                 fs_instance_t *inst = list_get_instance(link, fs_instance_t,
    927                     link);
    928 
    929                 if (inst->service_id == service_id) {
    930                         *idp = inst->data;
    931                         fibril_mutex_unlock(&instances_mutex);
    932                         return EOK;
    933                 }
    934         }
    935         fibril_mutex_unlock(&instances_mutex);
    936         return ENOENT;
    937 }
    938 
    939 int fs_instance_destroy(service_id_t service_id)
    940 {
    941         fibril_mutex_lock(&instances_mutex);
    942         list_foreach(instances_list, link) {
    943                 fs_instance_t *inst = list_get_instance(link, fs_instance_t,
    944                     link);
    945 
    946                 if (inst->service_id == service_id) {
    947                         list_remove(&inst->link);
    948                         fibril_mutex_unlock(&instances_mutex);
    949                         free(inst);
    950                         return EOK;
    951                 }
    952         }
    953         fibril_mutex_unlock(&instances_mutex);
    954         return ENOENT;
    955 }
    956 
    957879/** @}
    958880 */

  • uspace/lib/fs/libfs.h

    rb3bf143 rf1a9e87  
    105105extern void fs_node_initialize(fs_node_t *);
    106106
    107 extern int fs_instance_create(service_id_t, void *);
    108 extern int fs_instance_get(service_id_t, void **);
    109 extern int fs_instance_destroy(service_id_t);
    110 
    111107#endif
    112108

  • uspace/srv/fs/fat/fat.h

    rb3bf143 rf1a9e87  
    230230} fat_node_t;
    231231
    232 typedef struct {
    233         bool lfn_enabled;
    234 } fat_instance_t;
    235 
    236232extern vfs_out_ops_t fat_ops;
    237233extern libfs_ops_t fat_libfs_ops;

  • uspace/srv/fs/fat/fat_directory.c

    rb3bf143 rf1a9e87  
    262262{
    263263        int rc;
    264         void *data;
    265         fat_instance_t *instance;
    266 
    267         rc = fs_instance_get(di->nodep->idx->service_id, &data);
    268         assert(rc == EOK);
    269         instance = (fat_instance_t *) data;
     264        bool enable_lfn = true; /* TODO: make this a mount option */
    270265       
    271266        if (fat_valid_short_name(name)) {
    … …  
    282277                rc = fat_directory_write_dentry(di, de);
    283278                return rc;
    284         } else if (instance->lfn_enabled && fat_valid_name(name)) {
     279        } else if (enable_lfn && fat_valid_name(name)) {
    285280                /* We should create long entries to store name */
    286281                int long_entry_count;
    … …  
    297292                if (lfn_size % FAT_LFN_ENTRY_SIZE)
    298293                        long_entry_count++;
    299                 rc = fat_directory_lookup_free(di, long_entry_count + 1);
     294                rc = fat_directory_lookup_free(di, long_entry_count+1);
    300295                if (rc != EOK)
    301296                        return rc;
    … …  
    333328                FAT_LFN_ORDER(d) |= FAT_LFN_LAST;
    334329
    335                 rc = fat_directory_seek(di, start_pos + long_entry_count);
     330                rc = fat_directory_seek(di, start_pos+long_entry_count);
    336331                return rc;
    337332        }

  • uspace/srv/fs/fat/fat_ops.c

    rb3bf143 rf1a9e87  
    871871    aoff64_t *size, unsigned *linkcnt)
    872872{
    873         enum cache_mode cmode = CACHE_MODE_WB;
     873        enum cache_mode cmode;
    874874        fat_bs_t *bs;
    875         fat_instance_t *instance;
    876         int rc;
    877 
    878         instance = malloc(sizeof(fat_instance_t));
    879         if (!instance)
    880                 return ENOMEM;
    881         instance->lfn_enabled = true;
    882 
    883         /* Parse mount options. */
    884         char *mntopts = (char *) opts;
    885         char *saveptr;
    886         char *opt;
    887         while ((opt = strtok_r(mntopts, " ,", &saveptr)) != NULL) {
    888                 if (str_cmp(opt, "wtcache") == 0)
    889                         cmode = CACHE_MODE_WT;
    890                 else if (str_cmp(opt, "nolfn") == 0)
    891                         instance->lfn_enabled = false;
    892                 mntopts = NULL;
    893         }
     875        int rc;
     876
     877        /* Check for option enabling write through. */
     878        if (str_cmp(opts, "wtcache") == 0)
     879                cmode = CACHE_MODE_WT;
     880        else
     881                cmode = CACHE_MODE_WB;
    894882
    895883        /* initialize libblock */
    896884        rc = block_init(EXCHANGE_SERIALIZE, service_id, BS_SIZE);
    897         if (rc != EOK) {
    898                 free(instance);
    899                 return rc;
    900         }
     885        if (rc != EOK)
     886                return rc;
    901887
    902888        /* prepare the boot block */
    903889        rc = block_bb_read(service_id, BS_BLOCK);
    904890        if (rc != EOK) {
    905                 free(instance);
    906891                block_fini(service_id);
    907892                return rc;
    … …  
    912897       
    913898        if (BPS(bs) != BS_SIZE) {
    914                 free(instance);
    915899                block_fini(service_id);
    916900                return ENOTSUP;
    … …  
    920904        rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode);
    921905        if (rc != EOK) {
    922                 free(instance);
    923906                block_fini(service_id);
    924907                return rc;
    … …  
    928911        rc = fat_sanity_check(bs, service_id);
    929912        if (rc != EOK) {
    930                 free(instance);
    931913                (void) block_cache_fini(service_id);
    932914                block_fini(service_id);
    … …  
    936918        rc = fat_idx_init_by_service_id(service_id);
    937919        if (rc != EOK) {
    938                 free(instance);
    939920                (void) block_cache_fini(service_id);
    940921                block_fini(service_id);
    … …  
    945926        fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
    946927        if (!rfn) {
    947                 free(instance);
    948928                (void) block_cache_fini(service_id);
    949929                block_fini(service_id);
    … …  
    955935        fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
    956936        if (!rootp) {
    957                 free(instance);
    958937                free(rfn);
    959938                (void) block_cache_fini(service_id);
    … …  
    966945        fat_idx_t *ridxp = fat_idx_get_by_pos(service_id, FAT_CLST_ROOTPAR, 0);
    967946        if (!ridxp) {
    968                 free(instance);
    969947                free(rfn);
    970948                free(rootp);
    … …  
    986964                rc = fat_clusters_get(&clusters, bs, service_id, rootp->firstc);
    987965                if (rc != EOK) {
    988                         fibril_mutex_unlock(&ridxp->lock);
    989                         free(instance);
    990966                        free(rfn);
    991967                        free(rootp);
    … …  
    998974        } else
    999975                rootp->size = RDE(bs) * sizeof(fat_dentry_t);
    1000 
    1001         rc = fs_instance_create(service_id, instance);
    1002         if (rc != EOK) {
    1003                 fibril_mutex_unlock(&ridxp->lock);
    1004                 free(instance);
    1005                 free(rfn);
    1006                 free(rootp);
    1007                 (void) block_cache_fini(service_id);
    1008                 block_fini(service_id);
    1009                 fat_idx_fini_by_service_id(service_id);
    1010                 return rc;
    1011         }
    1012976
    1013977        rootp->idx = ridxp;
    … …  
    10601024        (void) block_cache_fini(service_id);
    10611025        block_fini(service_id);
    1062 
    1063         void *data;
    1064         if (fs_instance_get(service_id, &data) == EOK) {
    1065                 fs_instance_destroy(service_id);
    1066                 free(data);
    1067         }
    10681026
    10691027        return EOK;

  • uspace/srv/fs/mfs/mfs.h

    rb3bf143 rf1a9e87  
    131131
    132132struct mfs_instance {
     133        link_t link;
    133134        service_id_t service_id;
    134135        struct mfs_sb_info *sbi;

  • uspace/srv/fs/mfs/mfs_ops.c

    rb3bf143 rf1a9e87  
    7373
    7474
     75static LIST_INITIALIZE(inst_list);
     76static FIBRIL_MUTEX_INITIALIZE(inst_list_mutex);
    7577static hash_table_t open_nodes;
    7678static FIBRIL_MUTEX_INITIALIZE(open_nodes_lock);
    … …  
    177179                return ENOMEM;
    178180        }
     181
     182        instance->open_nodes_cnt = 0;
    179183
    180184        sb = malloc(MFS_SUPERBLOCK_SIZE);
    … …  
    264268                free(instance);
    265269                free(sbi);
     270                free(sb);
    266271                block_cache_fini(service_id);
    267272                block_fini(service_id);
    … …  
    270275        }
    271276
    272         /*Initialize the instance structure and remember it*/
     277        /*Initialize the instance structure and add it to the list*/
     278        link_initialize(&instance->link);
    273279        instance->service_id = service_id;
    274280        instance->sbi = sbi;
    275         instance->open_nodes_cnt = 0;
    276         rc = fs_instance_create(service_id, instance);
    277         if (rc != EOK) {
    278                 free(instance);
    279                 free(sbi);
    280                 block_cache_fini(service_id);
    281                 block_fini(service_id);
    282                 mfsdebug("fs instance creation failed\n");
    283                 return rc;
    284         }
     281
     282        fibril_mutex_lock(&inst_list_mutex);
     283        list_append(&instance->link, &inst_list);
     284        fibril_mutex_unlock(&inst_list_mutex);
    285285
    286286        mfsdebug("mount successful\n");
    … …  
    315315        block_fini(service_id);
    316316
    317         /* Remove and destroy the instance */
    318         (void) fs_instance_destroy(service_id);
     317        /* Remove the instance from the list */
     318        fibril_mutex_lock(&inst_list_mutex);
     319        list_remove(&inst->link);
     320        fibril_mutex_unlock(&inst_list_mutex);
     321
    319322        free(inst->sbi);
    320323        free(inst);
    … …  
    10091012mfs_instance_get(service_id_t service_id, struct mfs_instance **instance)
    10101013{
    1011         void *data;
    1012         int rc;
    1013 
    1014         rc = fs_instance_get(service_id, &data);
    1015         if (rc == EOK) {
    1016                 *instance = (struct mfs_instance *) data;
    1017         } else {
    1018                 mfsdebug("instance not found\n");
    1019         }
    1020 
    1021         return rc;
     1014        struct mfs_instance *instance_ptr;
     1015
     1016        fibril_mutex_lock(&inst_list_mutex);
     1017
     1018        if (list_empty(&inst_list)) {
     1019                fibril_mutex_unlock(&inst_list_mutex);
     1020                return EINVAL;
     1021        }
     1022
     1023        list_foreach(inst_list, link) {
     1024                instance_ptr = list_get_instance(link, struct mfs_instance,
     1025                                                 link);
     1026
     1027                if (instance_ptr->service_id == service_id) {
     1028                        *instance = instance_ptr;
     1029                        fibril_mutex_unlock(&inst_list_mutex);
     1030                        return EOK;
     1031                }
     1032        }
     1033
     1034        mfsdebug("Instance not found\n");
     1035
     1036        fibril_mutex_unlock(&inst_list_mutex);
     1037        return EINVAL;
    10221038}
    10231039
Note: See TracChangeset for help on using the changeset viewer.