Changeset 6ebe721 in mainline


Ignore:
Timestamp:
2009-06-17T22:07:42Z (15 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4e1b57d
Parents:
34ca870
Message:

Use fibril synchronization in FAT.

Location:
uspace/srv/fs/fat
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r34ca870 r6ebe721  
    3636#include "fat_fat.h"
    3737#include <ipc/ipc.h>
     38#include <fibril_sync.h>
    3839#include <libfs.h>
    3940#include <atomic.h>
    … …  
    161162        link_t          uih_link;
    162163
    163         futex_t         lock;
     164        fibril_mutex_t  lock;
    164165        dev_handle_t    dev_handle;
    165166        fs_index_t      index;
    … …  
    182183        fs_node_t               *bp;
    183184       
    184         futex_t                 lock;
     185        fibril_mutex_t          lock;
    185186        fat_node_type_t         type;
    186187        fat_idx_t               *idx;

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

    r34ca870 r6ebe721  
    4646#include <align.h>
    4747#include <assert.h>
    48 #include <futex.h>
     48#include <fibril_sync.h>
    4949#include <mem.h>
    5050
    5151/**
    52  * The fat_alloc_lock futex protects all copies of the File Allocation Table
     52 * The fat_alloc_lock mutex protects all copies of the File Allocation Table
    5353 * during allocation of clusters. The lock does not have to be held durring
    5454 * deallocation of clusters.
    5555 */ 
    56 static futex_t fat_alloc_lock = FUTEX_INITIALIZER;
     56static FIBRIL_MUTEX_INITIALIZE(fat_alloc_lock);
    5757
    5858/** Walk the cluster chain.
    … …  
    327327         * Search FAT1 for unused clusters.
    328328         */
    329         futex_down(&fat_alloc_lock);
     329        fibril_mutex_lock(&fat_alloc_lock);
    330330        for (b = 0, cl = 0; b < sf; b++) {
    331331                blk = block_get(dev_handle, rscnt + b, BLOCK_FLAGS_NONE);
    … …  
    351351                                        *lcl = lifo[0];
    352352                                        free(lifo);
    353                                         futex_up(&fat_alloc_lock);
     353                                        fibril_mutex_unlock(&fat_alloc_lock);
    354354                                        return EOK;
    355355                                }
    … …  
    358358                block_put(blk);
    359359        }
    360         futex_up(&fat_alloc_lock);
     360        fibril_mutex_unlock(&fat_alloc_lock);
    361361
    362362        /*

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

    r34ca870 r6ebe721  
    4343#include <adt/list.h>
    4444#include <assert.h>
    45 #include <futex.h>
     45#include <fibril_sync.h>
    4646
    4747/** Each instance of this type describes one interval of freed VFS indices. */
    … …  
    6969} unused_t;
    7070
    71 /** Futex protecting the list of unused structures. */
    72 static futex_t unused_futex = FUTEX_INITIALIZER;
     71/** Mutex protecting the list of unused structures. */
     72static FIBRIL_MUTEX_INITIALIZE(unused_lock);
    7373
    7474/** List of unused structures. */
    … …  
    9090
    9191        if (lock)
    92                 futex_down(&unused_futex);
     92                fibril_mutex_lock(&unused_lock);
    9393        for (l = unused_head.next; l != &unused_head; l = l->next) {
    9494                u = list_get_instance(l, unused_t, link);
    … …  
    9797        }
    9898        if (lock)
    99                 futex_up(&unused_futex);
     99                fibril_mutex_unlock(&unused_lock);
    100100        return NULL;
    101101}
    102102
    103 /** Futex protecting the up_hash and ui_hash. */
    104 static futex_t used_futex = FUTEX_INITIALIZER;
     103/** Mutex protecting the up_hash and ui_hash. */
     104static FIBRIL_MUTEX_INITIALIZE(used_lock);
    105105
    106106/**
    … …  
    232232                        *index = u->next++;
    233233                        --u->remaining;
    234                         futex_up(&unused_futex);
     234                        fibril_mutex_unlock(&unused_lock);
    235235                        return true;
    236236                }
    … …  
    245245                        free(f);
    246246                }
    247                 futex_up(&unused_futex);
     247                fibril_mutex_unlock(&unused_lock);
    248248                return true;
    249249        }
    … …  
    253253         * too many zero-sized nodes).
    254254         */
    255         futex_up(&unused_futex);
     255        fibril_mutex_unlock(&unused_lock);
    256256        return false;
    257257}
    … …  
    303303                                        try_coalesce_intervals(lnk->prev, lnk,
    304304                                            lnk);
    305                                 futex_up(&unused_futex);
     305                                fibril_mutex_unlock(&unused_lock);
    306306                                return;
    307307                        }
    … …  
    311311                                        try_coalesce_intervals(lnk, lnk->next,
    312312                                            lnk);
    313                                 futex_up(&unused_futex);
     313                                fibril_mutex_unlock(&unused_lock);
    314314                                return;
    315315                        }
    … …  
    322322                                n->last = index;
    323323                                list_insert_before(&n->link, lnk);
    324                                 futex_up(&unused_futex);
     324                                fibril_mutex_unlock(&unused_lock);
    325325                                return;
    326326                        }
    … …  
    336336                list_append(&n->link, &u->freed_head);
    337337        }
    338         futex_up(&unused_futex);
     338        fibril_mutex_unlock(&unused_lock);
    339339}
    340340
    … …  
    353353        link_initialize(&fidx->uph_link);
    354354        link_initialize(&fidx->uih_link);
    355         futex_initialize(&fidx->lock, 1);
     355        fibril_mutex_initialize(&fidx->lock);
    356356        fidx->dev_handle = dev_handle;
    357357        fidx->pfc = FAT_CLST_RES0;      /* no parent yet */
    … …  
    366366        fat_idx_t *fidx;
    367367
    368         futex_down(&used_futex);
     368        fibril_mutex_lock(&used_lock);
    369369        fidx = fat_idx_create(dev_handle);
    370370        if (!fidx) {
    371                 futex_up(&used_futex);
     371                fibril_mutex_unlock(&used_lock);
    372372                return NULL;
    373373        }
    … …  
    379379       
    380380        hash_table_insert(&ui_hash, ikey, &fidx->uih_link);
    381         futex_down(&fidx->lock);
    382         futex_up(&used_futex);
     381        fibril_mutex_lock(&fidx->lock);
     382        fibril_mutex_unlock(&used_lock);
    383383
    384384        return fidx;
    … …  
    396396        };
    397397
    398         futex_down(&used_futex);
     398        fibril_mutex_lock(&used_lock);
    399399        l = hash_table_find(&up_hash, pkey);
    400400        if (l) {
    … …  
    403403                fidx = fat_idx_create(dev_handle);
    404404                if (!fidx) {
    405                         futex_up(&used_futex);
     405                        fibril_mutex_unlock(&used_lock);
    406406                        return NULL;
    407407                }
    … …  
    418418                hash_table_insert(&ui_hash, ikey, &fidx->uih_link);
    419419        }
    420         futex_down(&fidx->lock);
    421         futex_up(&used_futex);
     420        fibril_mutex_lock(&fidx->lock);
     421        fibril_mutex_unlock(&used_lock);
    422422
    423423        return fidx;
    … …  
    432432        };
    433433
    434         futex_down(&used_futex);
     434        fibril_mutex_lock(&used_lock);
    435435        hash_table_insert(&up_hash, pkey, &idx->uph_link);
    436         futex_up(&used_futex);
     436        fibril_mutex_unlock(&used_lock);
    437437}
    438438
    … …  
    445445        };
    446446
    447         futex_down(&used_futex);
     447        fibril_mutex_lock(&used_lock);
    448448        hash_table_remove(&up_hash, pkey, 3);
    449         futex_up(&used_futex);
     449        fibril_mutex_unlock(&used_lock);
    450450}
    451451
    … …  
    460460        };
    461461
    462         futex_down(&used_futex);
     462        fibril_mutex_lock(&used_lock);
    463463        l = hash_table_find(&ui_hash, ikey);
    464464        if (l) {
    … …  
    466466                futex_down(&fidx->lock);
    467467        }
    468         futex_up(&used_futex);
     468        fibril_mutex_unlock(&used_lock);
    469469
    470470        return fidx;
    … …  
    484484        assert(idx->pfc == FAT_CLST_RES0);
    485485
    486         futex_down(&used_futex);
     486        fibril_mutex_lock(&used_lock);
    487487        /*
    488488         * Since we can only free unlinked nodes, the index structure is not
    … …  
    491491         */
    492492        hash_table_remove(&ui_hash, ikey, 2);
    493         futex_up(&used_futex);
     493        fibril_mutex_unlock(&used_lock);
    494494        /* Release the VFS index. */
    495495        fat_index_free(idx->dev_handle, idx->index);
    … …  
    525525                return ENOMEM;
    526526        unused_initialize(u, dev_handle);
    527         futex_down(&unused_futex);
     527        fibril_mutex_lock(&unused_lock);
    528528        if (!unused_find(dev_handle, false))
    529529                list_append(&u->link, &unused_head);
    530530        else
    531531                rc = EEXIST;
    532         futex_up(&unused_futex);
     532        fibril_mutex_unlock(&unused_lock);
    533533        return rc;
    534534}
    … …  
    541541        assert(u);
    542542        list_remove(&u->link);
    543         futex_up(&unused_futex);
     543        fibril_mutex_unlock(&unused_lock);
    544544
    545545        while (!list_empty(&u->freed_head)) {

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

    r34ca870 r6ebe721  
    5252#include <adt/list.h>
    5353#include <assert.h>
    54 #include <futex.h>
     54#include <fibril_sync.h>
    5555#include <sys/mman.h>
    5656#include <align.h>
    … …  
    5959#define FS_NODE(node)   ((node) ? (node)->bp : NULL)
    6060
    61 /** Futex protecting the list of cached free FAT nodes. */
    62 static futex_t ffn_futex = FUTEX_INITIALIZER;
     61/** Mutex protecting the list of cached free FAT nodes. */
     62static FIBRIL_MUTEX_INITIALIZE(ffn_mutex);
    6363
    6464/** List of cached free FAT nodes. */
    … …  
    6767static void fat_node_initialize(fat_node_t *node)
    6868{
    69         futex_initialize(&node->lock, 1);
     69        fibril_mutex_initialize(&node->lock);
    7070        node->bp = NULL;
    7171        node->idx = NULL;
    … …  
    116116        fat_node_t *nodep;
    117117
    118         futex_down(&ffn_futex);
     118        fibril_mutex_lock(&ffn_mutex);
    119119        if (!list_empty(&ffn_head)) {
    120120                /* Try to use a cached free node structure. */
    121121                fat_idx_t *idxp_tmp;
    122122                nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
    123                 if (futex_trydown(&nodep->lock) == ESYNCH_WOULD_BLOCK)
     123                if (!fibril_mutex_trylock(&nodep->lock))
    124124                        goto skip_cache;
    125125                idxp_tmp = nodep->idx;
    126                 if (futex_trydown(&idxp_tmp->lock) == ESYNCH_WOULD_BLOCK) {
    127                         futex_up(&nodep->lock);
     126                if (!fibril_mutex_trylock(&idxp_tmp->lock)) {
     127                        fibril_mutex_unlock(&nodep->lock);
    128128                        goto skip_cache;
    129129                }
    130130                list_remove(&nodep->ffn_link);
    131                 futex_up(&ffn_futex);
     131                fibril_mutex_unlock(&ffn_mutex);
    132132                if (nodep->dirty)
    133133                        fat_node_sync(nodep);
    134134                idxp_tmp->nodep = NULL;
    135                 futex_up(&nodep->lock);
    136                 futex_up(&idxp_tmp->lock);
     135                fibril_mutex_unlock(&nodep->lock);
     136                fibril_mutex_unlock(&idxp_tmp->lock);
    137137                fn = FS_NODE(nodep);
    138138        } else {
    139139skip_cache:
    140140                /* Try to allocate a new node structure. */
    141                 futex_up(&ffn_futex);
     141                fibril_mutex_unlock(&ffn_mutex);
    142142                fn = (fs_node_t *)malloc(sizeof(fs_node_t));
    143143                if (!fn)
    … …  
    176176                 * The node is already instantiated in memory.
    177177                 */
    178                 futex_down(&idxp->nodep->lock);
     178                fibril_mutex_lock(&idxp->nodep->lock);
    179179                if (!idxp->nodep->refcnt++)
    180180                        list_remove(&idxp->nodep->ffn_link);
    181                 futex_up(&idxp->nodep->lock);
     181                fibril_mutex_unlock(&idxp->nodep->lock);
    182182                return idxp->nodep;
    183183        }
    … …  
    269269        /* idxp->lock held */
    270270        nodep = fat_node_get_core(idxp);
    271         futex_up(&idxp->lock);
     271        fibril_mutex_unlock(&idxp->lock);
    272272        return FS_NODE(nodep);
    273273}
    … …  
    278278        bool destroy = false;
    279279
    280         futex_down(&nodep->lock);
     280        fibril_mutex_lock(&nodep->lock);
    281281        if (!--nodep->refcnt) {
    282282                if (nodep->idx) {
    283                         futex_down(&ffn_futex);
     283                        fibril_mutex_lock(&ffn_mutex);
    284284                        list_append(&nodep->ffn_link, &ffn_head);
    285                         futex_up(&ffn_futex);
     285                        fibril_mutex_unlock(&ffn_mutex);
    286286                } else {
    287287                        /*
    … …  
    294294                }
    295295        }
    296         futex_up(&nodep->lock);
     296        fibril_mutex_unlock(&nodep->lock);
    297297        if (destroy) {
    298298                free(nodep->bp);
    … …  
    361361        idxp->nodep = nodep;
    362362
    363         futex_up(&idxp->lock);
     363        fibril_mutex_unlock(&idxp->lock);
    364364        return FS_NODE(nodep);
    365365}
    … …  
    410410        int rc;
    411411
    412         futex_down(&childp->lock);
     412        fibril_mutex_lock(&childp->lock);
    413413        if (childp->lnkcnt == 1) {
    414414                /*
    415415                 * On FAT, we don't support multiple hard links.
    416416                 */
    417                 futex_up(&childp->lock);
     417                fibril_mutex_unlock(&childp->lock);
    418418                return EMLINK;
    419419        }
    420420        assert(childp->lnkcnt == 0);
    421         futex_up(&childp->lock);
     421        fibril_mutex_unlock(&childp->lock);
    422422
    423423        if (!fat_dentry_name_verify(name)) {
    … …  
    433433         */
    434434       
    435         futex_down(&parentp->idx->lock);
     435        fibril_mutex_lock(&parentp->idx->lock);
    436436        bs = block_bb_get(parentp->idx->dev_handle);
    437437        bps = uint16_t_le2host(bs->bps);
    … …  
    464464        if (parentp->idx->pfc == FAT_CLST_ROOT) {
    465465                /* Can't grow the root directory. */
    466                 futex_up(&parentp->idx->lock);
     466                fibril_mutex_unlock(&parentp->idx->lock);
    467467                return ENOSPC;
    468468        }
    469469        rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
    470470        if (rc != EOK) {
    471                 futex_up(&parentp->idx->lock);
     471                fibril_mutex_unlock(&parentp->idx->lock);
    472472                return rc;
    473473        }
    … …  
    492492        b->dirty = true;                /* need to sync block */
    493493        block_put(b);
    494         futex_up(&parentp->idx->lock);
    495 
    496         futex_down(&childp->idx->lock);
     494        fibril_mutex_unlock(&parentp->idx->lock);
     495
     496        fibril_mutex_lock(&childp->idx->lock);
    497497       
    498498        /*
    … …  
    530530        childp->idx->pfc = parentp->firstc;
    531531        childp->idx->pdi = i * dps + j;
    532         futex_up(&childp->idx->lock);
    533 
    534         futex_down(&childp->lock);
     532        fibril_mutex_unlock(&childp->idx->lock);
     533
     534        fibril_mutex_lock(&childp->lock);
    535535        childp->lnkcnt = 1;
    536536        childp->dirty = true;           /* need to sync node */
    537         futex_up(&childp->lock);
     537        fibril_mutex_unlock(&childp->lock);
    538538
    539539        /*
    … …  
    560560                return ENOTEMPTY;
    561561
    562         futex_down(&parentp->lock);
    563         futex_down(&childp->lock);
     562        fibril_mutex_lock(&parentp->lock);
     563        fibril_mutex_lock(&childp->lock);
    564564        assert(childp->lnkcnt == 1);
    565         futex_down(&childp->idx->lock);
     565        fibril_mutex_lock(&childp->idx->lock);
    566566        bs = block_bb_get(childp->idx->dev_handle);
    567567        bps = uint16_t_le2host(bs->bps);
    … …  
    582582        childp->idx->pfc = FAT_CLST_RES0;
    583583        childp->idx->pdi = 0;
    584         futex_up(&childp->idx->lock);
     584        fibril_mutex_unlock(&childp->idx->lock);
    585585        childp->lnkcnt = 0;
    586586        childp->dirty = true;
    587         futex_up(&childp->lock);
    588         futex_up(&parentp->lock);
     587        fibril_mutex_unlock(&childp->lock);
     588        fibril_mutex_unlock(&parentp->lock);
    589589
    590590        return EOK;
    … …  
    603603        block_t *b;
    604604
    605         futex_down(&parentp->idx->lock);
     605        fibril_mutex_lock(&parentp->idx->lock);
    606606        bs = block_bb_get(parentp->idx->dev_handle);
    607607        bps = uint16_t_le2host(bs->bps);
    … …  
    618618                        case FAT_DENTRY_LAST:
    619619                                block_put(b);
    620                                 futex_up(&parentp->idx->lock);
     620                                fibril_mutex_unlock(&parentp->idx->lock);
    621621                                return NULL;
    622622                        default:
    … …  
    637637                                    parentp->idx->dev_handle, parentp->firstc,
    638638                                    i * dps + j);
    639                                 futex_up(&parentp->idx->lock);
     639                                fibril_mutex_unlock(&parentp->idx->lock);
    640640                                if (!idx) {
    641641                                        /*
    … …  
    647647                                }
    648648                                nodep = fat_node_get_core(idx);
    649                                 futex_up(&idx->lock);
     649                                fibril_mutex_unlock(&idx->lock);
    650650                                block_put(b);
    651651                                return FS_NODE(nodep);
    … …  
    655655        }
    656656
    657         futex_up(&parentp->idx->lock);
     657        fibril_mutex_unlock(&parentp->idx->lock);
    658658        return NULL;
    659659}
    … …  
    687687                return false;
    688688       
    689         futex_down(&nodep->idx->lock);
     689        fibril_mutex_lock(&nodep->idx->lock);
    690690        bs = block_bb_get(nodep->idx->dev_handle);
    691691        bps = uint16_t_le2host(bs->bps);
    … …  
    706706                        case FAT_DENTRY_LAST:
    707707                                block_put(b);
    708                                 futex_up(&nodep->idx->lock);
     708                                fibril_mutex_unlock(&nodep->idx->lock);
    709709                                return false;
    710710                        default:
    711711                        case FAT_DENTRY_VALID:
    712712                                block_put(b);
    713                                 futex_up(&nodep->idx->lock);
     713                                fibril_mutex_unlock(&nodep->idx->lock);
    714714                                return true;
    715715                        }
    716716                        block_put(b);
    717                         futex_up(&nodep->idx->lock);
     717                        fibril_mutex_unlock(&nodep->idx->lock);
    718718                        return true;
    719719                }
    … …  
    721721        }
    722722
    723         futex_up(&nodep->idx->lock);
     723        fibril_mutex_unlock(&nodep->idx->lock);
    724724        return false;
    725725}
    … …  
    882882        rfn->data = rootp;
    883883       
    884         futex_up(&ridxp->lock);
     884        fibril_mutex_unlock(&ridxp->lock);
    885885
    886886        ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
Note: See TracChangeset for help on using the changeset viewer.