Changeset 6ebe721 in mainline for uspace/srv/fs/fat/fat_ops.c


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.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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.