Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 230260ac in mainline


Ignore:
Timestamp:
2009-06-09T22:27:43Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial
Children:
0e31a2b
Parents:
041186f
Message:

Make VFS use the new synchronization for fibrils. Now there should be no (or
only secondary) fibril serialization. Code reorganized not to hold the phone
lock during async_wait_for() in most cases. Tested on ia32. On amd64, VFS
crashes, but I think it is an unrelated problem.

Location:
uspace/srv/vfs
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/vfs/vfs.h

    r041186f r230260ac  
    3636#include <ipc/ipc.h>
    3737#include <adt/list.h>
     38#include <fibril_sync.h>
    3839#include <futex.h>
    39 #include <rwlock.h>
    4040#include <sys/types.h>
    4141#include <devmap.h>
     
    5555        vfs_info_t vfs_info;
    5656        fs_handle_t fs_handle;
    57         futex_t phone_futex;    /**< Phone serializing futex. */
     57        fibril_mutex_t phone_lock;
    5858        ipcarg_t phone;
    5959} fs_info_t;
     
    123123         * Holding this rwlock prevents modifications of the node's contents.
    124124         */
    125         rwlock_t contents_rwlock;
     125        fibril_rwlock_t contents_rwlock;
    126126} vfs_node_t;
    127127
     
    132132typedef struct {
    133133        /** Serializes access to this open file. */
    134         futex_t lock;
     134        fibril_mutex_t lock;
    135135
    136136        vfs_node_t *node;
     
    166166
    167167/** Holding this rwlock prevents changes in file system namespace. */
    168 extern rwlock_t namespace_rwlock;
     168extern fibril_rwlock_t namespace_rwlock;
    169169
    170170extern int vfs_grab_phone(fs_handle_t);
  • uspace/srv/vfs/vfs_file.c

    r041186f r230260ac  
    4141#include <assert.h>
    4242#include <bool.h>
     43#include <fibril_sync.h>
    4344#include "vfs.h"
    4445
     
    9091                       
    9192                        memset(files[i], 0, sizeof(vfs_file_t));
    92                         futex_initialize(&files[i]->lock, 1);
     93                        fibril_mutex_initialize(&files[i]->lock);
    9394                        vfs_file_addref(files[i]);
    9495                        return (int) i;
  • uspace/srv/vfs/vfs_lookup.c

    r041186f r230260ac  
    166166        vfs_release_phone(phone);
    167167       
    168         async_serialize_start();
    169168        ipcarg_t rc;
    170169        async_wait_for(req, &rc);
    171         async_serialize_end();
    172170       
    173171        futex_down(&plb_futex);
  • uspace/srv/vfs/vfs_node.c

    r041186f r230260ac  
    4040#include <string.h>
    4141#include <futex.h>
    42 #include <rwlock.h>
     42#include <fibril_sync.h>
    4343#include <adt/hash_table.h>
    4444#include <assert.h>
     
    178178                node->type = result->type;
    179179                link_initialize(&node->nh_link);
    180                 rwlock_initialize(&node->contents_rwlock);
     180                fibril_rwlock_initialize(&node->contents_rwlock);
    181181                hash_table_insert(&nodes, key, &node->nh_link);
    182182        } else {
  • uspace/srv/vfs/vfs_ops.c

    r041186f r230260ac  
    4545#include <bool.h>
    4646#include <futex.h>
    47 #include <rwlock.h>
     47#include <fibril_sync.h>
    4848#include <adt/list.h>
    4949#include <unistd.h>
     
    7373 * concurrent VFS operation which modifies the file system namespace.
    7474 */
    75 RWLOCK_INITIALIZE(namespace_rwlock);
     75FIBRIL_RWLOCK_INITIALIZE(namespace_rwlock);
    7676
    7777vfs_pair_t rootfs = {
     
    9696       
    9797        /* Resolve the path to the mountpoint. */
    98         rwlock_write_lock(&namespace_rwlock);
     98        fibril_rwlock_write_lock(&namespace_rwlock);
    9999        if (rootfs.fs_handle) {
    100100                /* We already have the root FS. */
    101101                if (str_cmp(mp, "/") == 0) {
    102102                        /* Trying to mount root FS over root FS */
     103                        fibril_rwlock_write_unlock(&namespace_rwlock);
    103104                        ipc_answer_0(rid, EBUSY);
    104                         rwlock_write_unlock(&namespace_rwlock);
    105105                        return;
    106106                }
     
    109109                if (rc != EOK) {
    110110                        /* The lookup failed for some reason. */
     111                        fibril_rwlock_write_unlock(&namespace_rwlock);
    111112                        ipc_answer_0(rid, rc);
    112                         rwlock_write_unlock(&namespace_rwlock);
    113113                        return;
    114114                }
     
    116116                mp_node = vfs_node_get(&mp_res);
    117117                if (!mp_node) {
     118                        fibril_rwlock_write_unlock(&namespace_rwlock);
    118119                        ipc_answer_0(rid, ENOMEM);
    119                         rwlock_write_unlock(&namespace_rwlock);
    120120                        return;
    121121                }
     
    142142                            str_size(opts));
    143143                        if (rc != EOK) {
     144                                vfs_release_phone(phone);
    144145                                async_wait_for(msg, NULL);
    145                                 vfs_release_phone(phone);
     146                                fibril_rwlock_write_unlock(&namespace_rwlock);
    146147                                ipc_answer_0(rid, rc);
    147                                 rwlock_write_unlock(&namespace_rwlock);
    148148                                return;
    149149                        }
     150                        vfs_release_phone(phone);
    150151                        async_wait_for(msg, &rc);
    151                         vfs_release_phone(phone);
    152152                       
    153153                        if (rc != EOK) {
     154                                fibril_rwlock_write_unlock(&namespace_rwlock);
    154155                                ipc_answer_0(rid, rc);
    155                                 rwlock_write_unlock(&namespace_rwlock);
    156156                                return;
    157157                        }
     
    175175                        assert(mr_node);
    176176                       
     177                        fibril_rwlock_write_unlock(&namespace_rwlock);
    177178                        ipc_answer_0(rid, rc);
    178                         rwlock_write_unlock(&namespace_rwlock);
    179179                        return;
    180180                } else {
     
    183183                         * being mounted first.
    184184                         */
     185                        fibril_rwlock_write_unlock(&namespace_rwlock);
    185186                        ipc_answer_0(rid, ENOENT);
    186                         rwlock_write_unlock(&namespace_rwlock);
    187187                        return;
    188188                }
     
    208208        rc = async_req_1_0(phone, IPC_M_CONNECTION_CLONE, mountee_phone);
    209209        if (rc != EOK) {
     210                vfs_release_phone(phone);
    210211                async_wait_for(msg, NULL);
    211                 vfs_release_phone(phone);
    212212                /* Mount failed, drop reference to mp_node. */
    213213                if (mp_node)
    214214                        vfs_node_put(mp_node);
    215215                ipc_answer_0(rid, rc);
    216                 rwlock_write_unlock(&namespace_rwlock);
     216                fibril_rwlock_write_unlock(&namespace_rwlock);
    217217                return;
    218218        }
     
    221221        rc = ipc_data_write_start(phone, (void *)opts, str_size(opts));
    222222        if (rc != EOK) {
     223                vfs_release_phone(phone);
    223224                async_wait_for(msg, NULL);
    224                 vfs_release_phone(phone);
    225225                /* Mount failed, drop reference to mp_node. */
    226226                if (mp_node)
    227227                        vfs_node_put(mp_node);
    228                 ipc_answer_0(rid, rc);
    229                 rwlock_write_unlock(&namespace_rwlock);
    230                 return;
    231         }
     228                fibril_rwlock_write_unlock(&namespace_rwlock);
     229                ipc_answer_0(rid, rc);
     230                return;
     231        }
     232        vfs_release_phone(phone);
    232233        async_wait_for(msg, &rc);
    233         vfs_release_phone(phone);
    234234       
    235235        if (rc == EOK) {
     
    255255
    256256        ipc_answer_0(rid, rc);
    257         rwlock_write_unlock(&namespace_rwlock);
     257        fibril_rwlock_write_unlock(&namespace_rwlock);
    258258}
    259259
     
    509509         * L_DIRECTORY. Make sure that the user does not pass L_OPEN.
    510510         */
    511         if (((lflag & (L_FILE | L_DIRECTORY)) == 0)
    512             || ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY))
    513             || ((lflag & L_OPEN) != 0)) {
     511        if (((lflag & (L_FILE | L_DIRECTORY)) == 0) ||
     512            ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) ||
     513            ((lflag & L_OPEN) != 0)) {
    514514                ipc_answer_0(rid, EINVAL);
    515515                return;
     
    549549         */
    550550        if (lflag & L_CREATE)
    551                 rwlock_write_lock(&namespace_rwlock);
     551                fibril_rwlock_write_lock(&namespace_rwlock);
    552552        else
    553                 rwlock_read_lock(&namespace_rwlock);
     553                fibril_rwlock_read_lock(&namespace_rwlock);
    554554       
    555555        /* The path is now populated and we can call vfs_lookup_internal(). */
     
    558558        if (rc != EOK) {
    559559                if (lflag & L_CREATE)
    560                         rwlock_write_unlock(&namespace_rwlock);
     560                        fibril_rwlock_write_unlock(&namespace_rwlock);
    561561                else
    562                         rwlock_read_unlock(&namespace_rwlock);
     562                        fibril_rwlock_read_unlock(&namespace_rwlock);
    563563                ipc_answer_0(rid, rc);
    564564                free(path);
     
    571571        vfs_node_t *node = vfs_node_get(&lr);
    572572        if (lflag & L_CREATE)
    573                 rwlock_write_unlock(&namespace_rwlock);
     573                fibril_rwlock_write_unlock(&namespace_rwlock);
    574574        else
    575                 rwlock_read_unlock(&namespace_rwlock);
     575                fibril_rwlock_read_unlock(&namespace_rwlock);
    576576       
    577577        /* Truncate the file if requested and if necessary. */
    578578        if (oflag & O_TRUNC) {
    579                 rwlock_write_lock(&node->contents_rwlock);
     579                fibril_rwlock_write_lock(&node->contents_rwlock);
    580580                if (node->size) {
    581581                        rc = vfs_truncate_internal(node->fs_handle,
    582582                            node->dev_handle, node->index, 0);
    583583                        if (rc) {
    584                                 rwlock_write_unlock(&node->contents_rwlock);
     584                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    585585                                vfs_node_put(node);
    586586                                ipc_answer_0(rid, rc);
     
    589589                        node->size = 0;
    590590                }
    591                 rwlock_write_unlock(&node->contents_rwlock);
     591                fibril_rwlock_write_unlock(&node->contents_rwlock);
    592592        }
    593593       
     
    640640        int oflag = IPC_GET_ARG4(*request);
    641641       
    642         rwlock_read_lock(&namespace_rwlock);
     642        fibril_rwlock_read_lock(&namespace_rwlock);
    643643       
    644644        int rc = vfs_open_node_internal(&lr);
    645645        if (rc != EOK) {
    646                 rwlock_read_unlock(&namespace_rwlock);
     646                fibril_rwlock_read_unlock(&namespace_rwlock);
    647647                ipc_answer_0(rid, rc);
    648648                return;
     
    650650       
    651651        vfs_node_t *node = vfs_node_get(&lr);
    652         rwlock_read_unlock(&namespace_rwlock);
     652        fibril_rwlock_read_unlock(&namespace_rwlock);
    653653       
    654654        /* Truncate the file if requested and if necessary. */
    655655        if (oflag & O_TRUNC) {
    656                 rwlock_write_lock(&node->contents_rwlock);
     656                fibril_rwlock_write_lock(&node->contents_rwlock);
    657657                if (node->size) {
    658658                        rc = vfs_truncate_internal(node->fs_handle,
    659659                            node->dev_handle, node->index, 0);
    660660                        if (rc) {
    661                                 rwlock_write_unlock(&node->contents_rwlock);
     661                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    662662                                vfs_node_put(node);
    663663                                ipc_answer_0(rid, rc);
     
    666666                        node->size = 0;
    667667                }
    668                 rwlock_write_unlock(&node->contents_rwlock);
     668                fibril_rwlock_write_unlock(&node->contents_rwlock);
    669669        }
    670670       
     
    709709        }
    710710       
    711         ipc_answer_3(rid, EOK, file->node->fs_handle,
    712             file->node->dev_handle, file->node->index);
     711        ipc_answer_3(rid, EOK, file->node->fs_handle, file->node->dev_handle,
     712            file->node->index);
    713713}
    714714
     
    728728         * the same open file at a time.
    729729         */
    730         futex_down(&file->lock);
     730        fibril_mutex_lock(&file->lock);
    731731        int fs_phone = vfs_grab_phone(file->node->fs_handle);
    732732       
     
    737737            file->node->dev_handle, file->node->index, &answer);
    738738       
     739        vfs_release_phone(fs_phone);
     740
    739741        /* Wait for reply from the FS server. */
    740742        ipcarg_t rc;
    741743        async_wait_for(msg, &rc);
    742744       
    743         vfs_release_phone(fs_phone);
    744         futex_up(&file->lock);
     745        fibril_mutex_unlock(&file->lock);
    745746       
    746747        ipc_answer_1(rid, EOK, IPC_GET_ARG1(answer));
     
    762763         * the same open file at a time.
    763764         */
    764         futex_down(&file->lock);
     765        fibril_mutex_lock(&file->lock);
    765766        int fs_phone = vfs_grab_phone(file->node->fs_handle);
    766767       
     
    770771        msg = async_send_2(fs_phone, IPC_GET_METHOD(*request),
    771772            file->node->dev_handle, file->node->index, &answer);
    772        
     773
     774        vfs_release_phone(fs_phone);
     775
    773776        /* Wait for reply from the FS server. */
    774777        ipcarg_t rc;
    775778        async_wait_for(msg, &rc);
    776779       
    777         vfs_release_phone(fs_phone);
    778         futex_up(&file->lock);
     780        fibril_mutex_unlock(&file->lock);
    779781       
    780782        ipc_answer_0(rid, rc);
     
    796798         * the same open file at a time.
    797799         */
    798         futex_down(&file->lock);
     800        fibril_mutex_lock(&file->lock);
    799801       
    800802        int fs_phone = vfs_grab_phone(file->node->fs_handle);
     
    805807        msg = async_send_2(fs_phone, IPC_GET_METHOD(*request),
    806808            file->node->dev_handle, file->node->index, &answer);
     809
     810        vfs_release_phone(fs_phone);
    807811       
    808812        /* Wait for reply from the FS server. */
     
    810814        async_wait_for(msg, &rc);
    811815       
    812         vfs_release_phone(fs_phone);
    813         futex_up(&file->lock);
     816        fibril_mutex_unlock(&file->lock);
    814817       
    815818        int retval = IPC_GET_ARG1(answer);
     
    863866         * the same open file at a time.
    864867         */
    865         futex_down(&file->lock);
     868        fibril_mutex_lock(&file->lock);
    866869
    867870        /*
     
    870873         */
    871874        if (read)
    872                 rwlock_read_lock(&file->node->contents_rwlock);
     875                fibril_rwlock_read_lock(&file->node->contents_rwlock);
    873876        else
    874                 rwlock_write_lock(&file->node->contents_rwlock);
     877                fibril_rwlock_write_lock(&file->node->contents_rwlock);
    875878
    876879        if (file->node->type == VFS_NODE_DIRECTORY) {
     
    880883                 */
    881884                assert(read);
    882                 rwlock_read_lock(&namespace_rwlock);
     885                fibril_rwlock_read_lock(&namespace_rwlock);
    883886        }
    884887       
     
    900903         */
    901904        ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     905
     906        vfs_release_phone(fs_phone);
    902907       
    903908        /* Wait for reply from the FS server. */
     
    905910        async_wait_for(msg, &rc);
    906911       
    907         vfs_release_phone(fs_phone);
    908        
    909912        size_t bytes = IPC_GET_ARG1(answer);
    910913
    911914        if (file->node->type == VFS_NODE_DIRECTORY)
    912                 rwlock_read_unlock(&namespace_rwlock);
     915                fibril_rwlock_read_unlock(&namespace_rwlock);
    913916       
    914917        /* Unlock the VFS node. */
    915918        if (read)
    916                 rwlock_read_unlock(&file->node->contents_rwlock);
     919                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    917920        else {
    918921                /* Update the cached version of node's size. */
    919922                if (rc == EOK)
    920923                        file->node->size = IPC_GET_ARG2(answer);
    921                 rwlock_write_unlock(&file->node->contents_rwlock);
     924                fibril_rwlock_write_unlock(&file->node->contents_rwlock);
    922925        }
    923926       
     
    925928        if (rc == EOK)
    926929                file->pos += bytes;
    927         futex_up(&file->lock);
     930        fibril_mutex_unlock(&file->lock);
    928931       
    929932        /*
     
    959962
    960963        off_t newpos;
    961         futex_down(&file->lock);
     964        fibril_mutex_lock(&file->lock);
    962965        if (whence == SEEK_SET) {
    963966                file->pos = off;
    964                 futex_up(&file->lock);
     967                fibril_mutex_unlock(&file->lock);
    965968                ipc_answer_1(rid, EOK, off);
    966969                return;
     
    968971        if (whence == SEEK_CUR) {
    969972                if (file->pos + off < file->pos) {
    970                         futex_up(&file->lock);
     973                        fibril_mutex_unlock(&file->lock);
    971974                        ipc_answer_0(rid, EOVERFLOW);
    972975                        return;
     
    974977                file->pos += off;
    975978                newpos = file->pos;
    976                 futex_up(&file->lock);
     979                fibril_mutex_unlock(&file->lock);
    977980                ipc_answer_1(rid, EOK, newpos);
    978981                return;
    979982        }
    980983        if (whence == SEEK_END) {
    981                 rwlock_read_lock(&file->node->contents_rwlock);
     984                fibril_rwlock_read_lock(&file->node->contents_rwlock);
    982985                size_t size = file->node->size;
    983                 rwlock_read_unlock(&file->node->contents_rwlock);
     986                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    984987                if (size + off < size) {
    985                         futex_up(&file->lock);
     988                        fibril_mutex_unlock(&file->lock);
    986989                        ipc_answer_0(rid, EOVERFLOW);
    987990                        return;
    988991                }
    989992                newpos = size + off;
    990                 futex_up(&file->lock);
     993                fibril_mutex_unlock(&file->lock);
    991994                ipc_answer_1(rid, EOK, newpos);
    992995                return;
    993996        }
    994         futex_up(&file->lock);
     997        fibril_mutex_unlock(&file->lock);
    995998        ipc_answer_0(rid, EINVAL);
    996999}
     
    10211024                return;
    10221025        }
    1023         futex_down(&file->lock);
    1024 
    1025         rwlock_write_lock(&file->node->contents_rwlock);
     1026        fibril_mutex_lock(&file->lock);
     1027
     1028        fibril_rwlock_write_lock(&file->node->contents_rwlock);
    10261029        rc = vfs_truncate_internal(file->node->fs_handle,
    10271030            file->node->dev_handle, file->node->index, size);
    10281031        if (rc == EOK)
    10291032                file->node->size = size;
    1030         rwlock_write_unlock(&file->node->contents_rwlock);
    1031 
    1032         futex_up(&file->lock);
     1033        fibril_rwlock_write_unlock(&file->node->contents_rwlock);
     1034
     1035        fibril_mutex_unlock(&file->lock);
    10331036        ipc_answer_0(rid, (ipcarg_t)rc);
    10341037}
     
    10601063        path[len] = '\0';
    10611064       
    1062         rwlock_write_lock(&namespace_rwlock);
     1065        fibril_rwlock_write_lock(&namespace_rwlock);
    10631066        int lflag = L_DIRECTORY | L_CREATE | L_EXCLUSIVE;
    10641067        rc = vfs_lookup_internal(path, lflag, NULL, NULL);
    1065         rwlock_write_unlock(&namespace_rwlock);
     1068        fibril_rwlock_write_unlock(&namespace_rwlock);
    10661069        free(path);
    10671070        ipc_answer_0(rid, rc);
     
    10941097        path[len] = '\0';
    10951098       
    1096         rwlock_write_lock(&namespace_rwlock);
     1099        fibril_rwlock_write_lock(&namespace_rwlock);
    10971100        lflag &= L_DIRECTORY;   /* sanitize lflag */
    10981101        vfs_lookup_res_t lr;
     
    11001103        free(path);
    11011104        if (rc != EOK) {
    1102                 rwlock_write_unlock(&namespace_rwlock);
     1105                fibril_rwlock_write_unlock(&namespace_rwlock);
    11031106                ipc_answer_0(rid, rc);
    11041107                return;
     
    11141117        node->lnkcnt--;
    11151118        futex_up(&nodes_futex);
    1116         rwlock_write_unlock(&namespace_rwlock);
     1119        fibril_rwlock_write_unlock(&namespace_rwlock);
    11171120        vfs_node_put(node);
    11181121        ipc_answer_0(rid, EOK);
     
    11951198        vfs_lookup_res_t new_lr;
    11961199        vfs_lookup_res_t new_par_lr;
    1197         rwlock_write_lock(&namespace_rwlock);
     1200        fibril_rwlock_write_lock(&namespace_rwlock);
    11981201        /* Lookup the node belonging to the old file name. */
    11991202        rc = vfs_lookup_internal(oldc, L_NONE, &old_lr, NULL);
    12001203        if (rc != EOK) {
    1201                 rwlock_write_unlock(&namespace_rwlock);
     1204                fibril_rwlock_write_unlock(&namespace_rwlock);
    12021205                ipc_answer_0(rid, rc);
    12031206                free(old);
     
    12071210        vfs_node_t *old_node = vfs_node_get(&old_lr);
    12081211        if (!old_node) {
    1209                 rwlock_write_unlock(&namespace_rwlock);
     1212                fibril_rwlock_write_unlock(&namespace_rwlock);
    12101213                ipc_answer_0(rid, ENOMEM);
    12111214                free(old);
     
    12161219        char *parentc = str_dup(newc);
    12171220        if (!parentc) {
    1218                 rwlock_write_unlock(&namespace_rwlock);
     1221                fibril_rwlock_write_unlock(&namespace_rwlock);
    12191222                ipc_answer_0(rid, rc);
    12201223                free(old);
     
    12311234        free(parentc);  /* not needed anymore */
    12321235        if (rc != EOK) {
    1233                 rwlock_write_unlock(&namespace_rwlock);
     1236                fibril_rwlock_write_unlock(&namespace_rwlock);
    12341237                ipc_answer_0(rid, rc);
    12351238                free(old);
     
    12401243        if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
    12411244            (old_node->dev_handle != new_par_lr.triplet.dev_handle)) {
    1242                 rwlock_write_unlock(&namespace_rwlock);
     1245                fibril_rwlock_write_unlock(&namespace_rwlock);
    12431246                ipc_answer_0(rid, EXDEV);       /* different file systems */
    12441247                free(old);
     
    12561259                new_node = vfs_node_get(&new_lr);
    12571260                if (!new_node) {
    1258                         rwlock_write_unlock(&namespace_rwlock);
     1261                        fibril_rwlock_write_unlock(&namespace_rwlock);
    12591262                        ipc_answer_0(rid, ENOMEM);
    12601263                        free(old);
     
    12671270                break;
    12681271        default:
    1269                 rwlock_write_unlock(&namespace_rwlock);
     1272                fibril_rwlock_write_unlock(&namespace_rwlock);
    12701273                ipc_answer_0(rid, ENOTEMPTY);
    12711274                free(old);
     
    12761279        rc = vfs_lookup_internal(newc, L_LINK, NULL, NULL, old_node->index);
    12771280        if (rc != EOK) {
    1278                 rwlock_write_unlock(&namespace_rwlock);
     1281                fibril_rwlock_write_unlock(&namespace_rwlock);
    12791282                if (new_node)
    12801283                        vfs_node_put(new_node);
     
    12901293        rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
    12911294        if (rc != EOK) {
    1292                 rwlock_write_unlock(&namespace_rwlock);
     1295                fibril_rwlock_write_unlock(&namespace_rwlock);
    12931296                vfs_node_put(old_node);
    12941297                if (new_node)
     
    13021305        old_node->lnkcnt--;
    13031306        futex_up(&nodes_futex);
    1304         rwlock_write_unlock(&namespace_rwlock);
     1307        fibril_rwlock_write_unlock(&namespace_rwlock);
    13051308        vfs_node_put(old_node);
    13061309        if (new_node)
  • uspace/srv/vfs/vfs_register.c

    r041186f r230260ac  
    4646#include <ctype.h>
    4747#include <bool.h>
    48 #include <futex.h>
     48#include <fibril_sync.h>
    4949#include <adt/list.h>
    5050#include <as.h>
     
    5353#include "vfs.h"
    5454
    55 atomic_t fs_head_futex = FUTEX_INITIALIZER;
     55FIBRIL_MUTEX_INITIALIZE(fs_head_lock);
    5656link_t fs_head;
    5757
     
    160160        }
    161161        link_initialize(&fs_info->fs_link);
    162         futex_initialize(&fs_info->phone_futex, 1);
     162        fibril_mutex_initialize(&fs_info->phone_lock);
    163163               
    164164        rc = ipc_data_write_finalize(callid, &fs_info->vfs_info, size);
     
    181181        }
    182182               
    183         futex_down(&fs_head_futex);
    184         fibril_inc_sercount();
     183        fibril_mutex_lock(&fs_head_lock);
    185184
    186185        /*
     
    192191                 */
    193192                dprintf("FS is already registered.\n");
    194                 fibril_dec_sercount();
    195                 futex_up(&fs_head_futex);
     193                fibril_mutex_unlock(&fs_head_lock);
    196194                free(fs_info);
    197195                ipc_answer_0(callid, EEXISTS);
     
    215213                dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
    216214                list_remove(&fs_info->fs_link);
    217                 fibril_dec_sercount();
    218                 futex_up(&fs_head_futex);
     215                fibril_mutex_unlock(&fs_head_lock);
    219216                free(fs_info);
    220217                ipc_answer_0(callid, EINVAL);
     
    234231                dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
    235232                list_remove(&fs_info->fs_link);
    236                 fibril_dec_sercount();
    237                 futex_up(&fs_head_futex);
     233                fibril_mutex_unlock(&fs_head_lock);
    238234                ipc_hangup(fs_info->phone);
    239235                free(fs_info);
     
    249245                dprintf("Client suggests wrong size of PFB, size = %d\n", size);
    250246                list_remove(&fs_info->fs_link);
    251                 fibril_dec_sercount();
    252                 futex_up(&fs_head_futex);
     247                fibril_mutex_unlock(&fs_head_lock);
    253248                ipc_hangup(fs_info->phone);
    254249                free(fs_info);
     
    274269        ipc_answer_1(rid, EOK, (ipcarg_t) fs_info->fs_handle);
    275270       
    276         fibril_dec_sercount();
    277         futex_up(&fs_head_futex);
     271        fibril_mutex_unlock(&fs_head_lock);
    278272       
    279273        dprintf("\"%.*s\" filesystem successfully registered, handle=%d.\n",
     
    298292         * phone_futex and keep it until vfs_release_phone().
    299293         */
    300         futex_down(&fs_head_futex);
     294        fibril_mutex_lock(&fs_head_lock);
    301295        link_t *cur;
    302296        fs_info_t *fs;
     
    304298                fs = list_get_instance(cur, fs_info_t, fs_link);
    305299                if (fs->fs_handle == handle) {
    306                         futex_up(&fs_head_futex);
    307                         /*
    308                          * For now, take the futex unconditionally.
    309                          * Oh yeah, serialization rocks.
    310                          * It will be up'ed in vfs_release_phone().
    311                          */
    312                         futex_down(&fs->phone_futex);
    313                         /*
    314                          * Avoid deadlock with other fibrils in the same thread
    315                          * by disabling fibril preemption.
    316                          */
    317                         fibril_inc_sercount();
     300                        fibril_mutex_unlock(&fs_head_lock);
     301                        fibril_mutex_lock(&fs->phone_lock);
    318302                        return fs->phone;
    319303                }
    320304        }
    321         futex_up(&fs_head_futex);
     305        fibril_mutex_unlock(&fs_head_lock);
    322306        return 0;
    323307}
     
    331315        bool found = false;
    332316
    333         /*
    334          * Undo the fibril_inc_sercount() done in vfs_grab_phone().
    335          */
    336         fibril_dec_sercount();
    337        
    338         futex_down(&fs_head_futex);
     317        fibril_mutex_lock(&fs_head_lock);
    339318        link_t *cur;
    340319        for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
     
    342321                if (fs->phone == phone) {
    343322                        found = true;
    344                         futex_up(&fs_head_futex);
    345                         futex_up(&fs->phone_futex);
     323                        fibril_mutex_unlock(&fs_head_lock);
     324                        fibril_mutex_unlock(&fs->phone_lock);
    346325                        return;
    347326                }
    348327        }
    349         futex_up(&fs_head_futex);
     328        fibril_mutex_unlock(&fs_head_lock);
    350329
    351330        /*
     
    358337 *
    359338 * @param name          File system name.
    360  * @param lock          If true, the function will down and up the
    361  *                      fs_head_futex.
     339 * @param lock          If true, the function will lock and unlock the
     340 *                      fs_head_lock.
    362341 *
    363342 * @return              File system handle or zero if file system not found.
     
    368347       
    369348        if (lock)
    370                 futex_down(&fs_head_futex);
     349                fibril_mutex_lock(&fs_head_lock);
    371350        link_t *cur;
    372351        for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
     
    378357        }
    379358        if (lock)
    380                 futex_up(&fs_head_futex);
     359                fibril_mutex_unlock(&fs_head_lock);
    381360        return handle;
    382361}
Note: See TracChangeset for help on using the changeset viewer.