Changeset a35b458 in mainline for uspace/srv/vfs


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:
uspace/srv/vfs
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs.c

    r3061bc1 ra35b458  
    6262                ipc_call_t call;
    6363                ipc_callid_t callid = async_get_call(&call);
    64                
     64
    6565                if (!IPC_GET_IMETHOD(call))
    6666                        break;
    67                
     67
    6868                switch (IPC_GET_IMETHOD(call)) {
    6969                case IPC_M_PAGE_IN:
    … …  
    9191
    9292        printf("%s: HelenOS VFS server\n", NAME);
    93        
     93
    9494        /*
    9595         * Initialize VFS node hash table.
    … …  
    100100                return ENOMEM;
    101101        }
    102        
     102
    103103        /*
    104104         * Allocate and initialize the Path Lookup Buffer.
    … …  
    111111        }
    112112        memset(plb, 0, PLB_SIZE);
    113        
     113
    114114        /*
    115115         * Set client data constructor and destructor.
    … …  
    138138        async_event_task_subscribe(EVENT_TASK_STATE_CHANGE, notification_handler,
    139139            NULL);
    140        
     140
    141141        /*
    142142         * Register at the naming service.
    … …  
    147147                return rc;
    148148        }
    149        
     149
    150150        /*
    151151         * Start accepting connections.

  • uspace/srv/vfs/vfs.h

    r3061bc1 ra35b458  
    110110         */
    111111        unsigned refcnt;
    112        
     112
    113113        ht_link_t nh_link;              /**< Node hash-table link. */
    114114
    … …  
    121121         */
    122122        fibril_rwlock_t contents_rwlock;
    123        
     123
    124124        struct _vfs_node *mount;
    125125} vfs_node_t;
    … …  
    134134
    135135        vfs_node_t *node;
    136        
     136
    137137        /** Number of file handles referencing this file. */
    138138        unsigned refcnt;

  • uspace/srv/vfs/vfs_file.c

    r3061bc1 ra35b458  
    9494                        (void) _vfs_fd_free(vfs_data, i);
    9595        }
    96        
     96
    9797        free(vfs_data->files);
    9898
    … …  
    100100                link_t *lnk;
    101101                vfs_boxed_handle_t *bh;
    102                
     102
    103103                lnk = list_first(&vfs_data->passed_handles);
    104104                list_remove(lnk);
    … …  
    120120                vfs_data->files = NULL;
    121121        }
    122        
     122
    123123        return vfs_data;
    124124}
    … …  
    136136{
    137137        assert(!file->refcnt);
    138        
     138
    139139        async_exch_t *exch = vfs_exchange_grab(file->node->fs_handle);
    140        
     140
    141141        ipc_call_t answer;
    142142        aid_t msg = async_send_2(exch, VFS_OUT_CLOSE, file->node->service_id,
    143143            file->node->index, &answer);
    144        
     144
    145145        vfs_exchange_release(exch);
    146        
     146
    147147        errno_t rc;
    148148        async_wait_for(msg, &rc);
    149        
     149
    150150        return IPC_GET_RETVAL(answer);
    151151}
    … …  
    179179                 * endpoint FS and drop our reference to the underlying VFS node.
    180180                 */
    181                
     181
    182182                if (file->node != NULL) {
    183183                        if (file->open_read || file->open_write) {
    … …  
    196196        if (!vfs_files_init(vfs_data))
    197197                return ENOMEM;
    198        
     198
    199199        unsigned int i;
    200200        if (desc)
    … …  
    202202        else
    203203                i = 0;
    204        
     204
    205205        fibril_mutex_lock(&vfs_data->lock);
    206206        while (true) {
    … …  
    211211                                return ENOMEM;
    212212                        }
    213                        
    214                        
     213
     214
    215215                        memset(vfs_data->files[i], 0, sizeof(vfs_file_t));
    216                        
     216
    217217                        fibril_mutex_initialize(&vfs_data->files[i]->_lock);
    218218                        fibril_mutex_lock(&vfs_data->files[i]->_lock);
    219219                        vfs_file_addref(vfs_data, vfs_data->files[i]);
    220                        
     220
    221221                        *file = vfs_data->files[i];
    222222                        vfs_file_addref(vfs_data, *file);
    223                        
     223
    224224                        fibril_mutex_unlock(&vfs_data->lock);
    225225                        *out_fd = (int) i;
    226226                        return EOK;
    227227                }
    228                
     228
    229229                if (desc) {
    230230                        if (i == 0)
    231231                                break;
    232                        
     232
    233233                        i--;
    234234                } else {
    235235                        if (i == MAX_OPEN_FILES - 1)
    236236                                break;
    237                        
     237
    238238                        i++;
    239239                }
    240240        }
    241241        fibril_mutex_unlock(&vfs_data->lock);
    242        
     242
    243243        return EMFILE;
    244244}
    … …  
    280280        rc = _vfs_fd_free_locked(vfs_data, fd);
    281281        fibril_mutex_unlock(&vfs_data->lock);
    282        
     282
    283283        return rc;
    284284}
    … …  
    319319        (void) _vfs_fd_free_locked(VFS_DATA, fd);
    320320        assert(FILES[fd] == NULL);
    321        
     321
    322322        FILES[fd] = file;
    323323        vfs_file_addref(VFS_DATA, FILES[fd]);
    324324        fibril_mutex_unlock(&VFS_DATA->lock);
    325        
     325
    326326        return EOK;
    327327}
    … …  
    330330{
    331331        fibril_mutex_unlock(&file->_lock);
    332        
     332
    333333        fibril_mutex_lock(&vfs_data->lock);
    334334        vfs_file_delref(vfs_data, file);
    … …  
    340340        if (!vfs_files_init(vfs_data))
    341341                return NULL;
    342        
     342
    343343        fibril_mutex_lock(&vfs_data->lock);
    344344        if ((fd >= 0) && (fd < MAX_OPEN_FILES)) {
    … …  
    347347                        vfs_file_addref(vfs_data, file);
    348348                        fibril_mutex_unlock(&vfs_data->lock);
    349                        
     349
    350350                        fibril_mutex_lock(&file->_lock);
    351351                        if (file->node == NULL) {
    … …  
    359359        }
    360360        fibril_mutex_unlock(&vfs_data->lock);
    361        
     361
    362362        return NULL;
    363363}
    … …  
    432432{
    433433        vfs_client_data_t *vfs_data = VFS_DATA;
    434        
     434
    435435        fibril_mutex_lock(&vfs_data->lock);
    436436        while (list_empty(&vfs_data->passed_handles))
    … …  
    449449                return rc;
    450450        }
    451        
     451
    452452        file->node = bh->node;
    453453        file->permissions = bh->permissions;

  • uspace/srv/vfs/vfs_ipc.c

    r3061bc1 ra35b458  
    4040        int newfd = IPC_GET_ARG2(*request);
    4141        bool desc = IPC_GET_ARG3(*request);
    42        
     42
    4343        int outfd = -1;
    4444        errno_t rc = vfs_op_clone(oldfd, newfd, desc, &outfd);
    … …  
    5454        size_t len;
    5555        errno_t rc;
    56        
     56
    5757        /*
    5858         * Now we expect the client to send us data with the name of the file
    … …  
    6565                return;
    6666        }
    67        
     67
    6868        rc = vfs_op_fsprobe(fs_name, service_id, &info);
    6969        async_answer_0(rid, rc);
    7070        if (rc != EOK)
    7171                goto out;
    72        
     72
    7373        /* Now we should get a read request */
    7474        if (!async_data_read_receive(&callid, &len))
    … …  
    114114{
    115115        int mpfd = IPC_GET_ARG1(*request);
    116        
     116
    117117        /*
    118118         * We expect the library to do the device-name to device-handle
    … …  
    121121         */
    122122        service_id_t service_id = (service_id_t) IPC_GET_ARG2(*request);
    123        
     123
    124124        unsigned int flags = (unsigned int) IPC_GET_ARG3(*request);
    125125        unsigned int instance = IPC_GET_ARG4(*request);
    126        
     126
    127127        char *opts = NULL;
    128128        char *fs_name = NULL;
    129        
     129
    130130        /* Now we expect to receive the mount options. */
    131131        errno_t rc = async_data_write_accept((void **) &opts, true, 0,
    … …  
    135135                return;
    136136        }
    137        
     137
    138138        /* Now, we expect the client to send us data with the name of the file
    139139         * system.
    … …  
    146146                return;
    147147        }
    148        
     148
    149149        int outfd = 0;
    150150        rc = vfs_op_mount(mpfd, service_id, flags, instance, opts, fs_name,
    151151             &outfd);
    152152        async_answer_1(rid, rc, outfd);
    153        
     153
    154154        free(opts);
    155155        free(fs_name);
    … …  
    190190        char *new = NULL;
    191191        errno_t rc;
    192        
     192
    193193        basefd = IPC_GET_ARG1(*request);
    194        
     194
    195195        /* Retrieve the old path. */
    196196        rc = async_data_write_accept((void **) &old, true, 0, 0, 0, NULL);
    197197        if (rc != EOK)
    198198                goto out;
    199        
     199
    200200        /* Retrieve the new path. */
    201201        rc = async_data_write_accept((void **) &new, true, 0, 0, 0, NULL);
    202202        if (rc != EOK)
    203203                goto out;
    204        
     204
    205205        size_t olen;
    206206        size_t nlen;
    207207        char *oldc = canonify(old, &olen);
    208208        char *newc = canonify(new, &nlen);
    209        
     209
    210210        if ((!oldc) || (!newc)) {
    211211                rc = EINVAL;
    212212                goto out;
    213213        }
    214        
     214
    215215        assert(oldc[olen] == '\0');
    216216        assert(newc[nlen] == '\0');
    217        
     217
    218218        rc = vfs_op_rename(basefd, oldc, newc);
    219219
    … …  
    245245{
    246246        int fd = (int) IPC_GET_ARG1(*request);
    247        
     247
    248248        errno_t rc = vfs_op_statfs(fd);
    249249        async_answer_0(rid, rc);
    … …  
    261261        int parentfd = IPC_GET_ARG1(*request);
    262262        int expectfd = IPC_GET_ARG2(*request);
    263        
     263
    264264        char *path;
    265265        errno_t rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    266266        if (rc == EOK)
    267267                rc = vfs_op_unlink(parentfd, expectfd, path);
    268        
     268
    269269        async_answer_0(rid, rc);
    270270}
    … …  
    293293        int parentfd = IPC_GET_ARG1(*request);
    294294        int flags = IPC_GET_ARG2(*request);
    295        
     295
    296296        int fd = 0;
    297297        char *path;
    … …  
    318318{
    319319        bool cont = true;
    320        
     320
    321321        /*
    322322         * The connection was opened via the IPC_CONNECT_ME_TO call.
    … …  
    324324         */
    325325        async_answer_0(iid, EOK);
    326        
     326
    327327        while (cont) {
    328328                ipc_call_t call;
    329329                ipc_callid_t callid = async_get_call(&call);
    330                
     330
    331331                if (!IPC_GET_IMETHOD(call))
    332332                        break;
    333                
     333
    334334                switch (IPC_GET_IMETHOD(call)) {
    335335                case VFS_IN_CLONE:
    … …  
    393393                }
    394394        }
    395        
     395
    396396        /*
    397397         * Open files for this client will be cleaned up when its last

  • uspace/srv/vfs/vfs_lookup.c

    r3061bc1 ra35b458  
    108108         */
    109109        list_append(&entry->plb_link, &plb_entries);
    110        
     110
    111111        fibril_mutex_unlock(&plb_mutex);
    112112
    … …  
    116116        size_t cnt1 = min(len, (PLB_SIZE - first) + 1);
    117117        size_t cnt2 = len - cnt1;
    118        
     118
    119119        memcpy(&plb[first], path, cnt1);
    120120        memcpy(plb, &path[cnt1], cnt2);
    … …  
    145145        assert(child->fs_handle);
    146146        assert(path != NULL);
    147        
     147
    148148        vfs_lookup_res_t res;
    149149        char component[NAME_MAX + 1];
    150150        errno_t rc;
    151        
     151
    152152        size_t len;
    153153        char *npath = canonify(path, &len);
    … …  
    157157        }
    158158        path = npath;
    159        
     159
    160160        vfs_triplet_t *triplet;
    161        
     161
    162162        char *slash = str_rchr(path, L'/');
    163163        if (slash && slash != path) {
    … …  
    166166                        goto out;
    167167                }
    168                
     168
    169169                memcpy(component, slash + 1, str_size(slash));
    170170                *slash = 0;
    171                
     171
    172172                rc = vfs_lookup_internal(base, path, L_DIRECTORY, &res);
    173173                if (rc != EOK)
    174174                        goto out;
    175175                triplet = &res.triplet;
    176                
     176
    177177                *slash = '/';
    178178        } else {
    … …  
    181181                        goto out;
    182182                }
    183                
     183
    184184                memcpy(component, path + 1, str_size(path));
    185185                triplet = (vfs_triplet_t *) base;
    186186        }
    187        
     187
    188188        if (triplet->fs_handle != child->fs_handle ||
    189189            triplet->service_id != child->service_id) {
    … …  
    191191                goto out;
    192192        }
    193        
     193
    194194        async_exch_t *exch = vfs_exchange_grab(triplet->fs_handle);
    195195        aid_t req = async_send_3(exch, VFS_OUT_LINK, triplet->service_id,
    196196            triplet->index, child->index, NULL);
    197        
     197
    198198        rc = async_data_write_start(exch, component, str_size(component) + 1);
    199199        errno_t orig_rc;
    … …  
    202202        if (orig_rc != EOK)
    203203                rc = orig_rc;
    204        
     204
    205205out:
    206206        return rc;
    … …  
    212212        assert(base);
    213213        assert(result);
    214        
     214
    215215        errno_t rc;
    216216        ipc_call_t answer;
    … …  
    221221        async_wait_for(req, &rc);
    222222        vfs_exchange_release(exch);
    223        
     223
    224224        if (rc != EOK)
    225225                return rc;
    226        
     226
    227227        unsigned last = *pfirst + *plen;
    228228        *pfirst = IPC_GET_ARG3(answer) & 0xffff;
    229229        *plen = last - *pfirst;
    230        
     230
    231231        result->triplet.fs_handle = (fs_handle_t) IPC_GET_ARG1(answer);
    232232        result->triplet.service_id = base->service_id;
    … …  
    248248        if (rc != EOK)
    249249                return rc;
    250        
     250
    251251        size_t next = first;
    252252        size_t nlen = len;
    253        
     253
    254254        vfs_lookup_res_t res;
    255        
     255
    256256        /* Resolve path as long as there are mount points to cross. */
    257257        while (nlen > 0) {
    … …  
    261261                                goto out;
    262262                        }
    263                        
     263
    264264                        base = base->mount;
    265265                }
    266                
     266
    267267                rc = out_lookup((vfs_triplet_t *) base, &next, &nlen, lflag,
    268268                    &res);
    269269                if (rc != EOK)
    270270                        goto out;
    271                
     271
    272272                if (nlen > 0) {
    273273                        base = vfs_node_peek(&res);
    … …  
    288288                }
    289289        }
    290        
     290
    291291        assert(nlen == 0);
    292292        rc = EOK;
    293        
     293
    294294        if (result != NULL) {
    295295                /* The found file may be a mount point. Try to cross it. */
    … …  
    303303                                        base = nbase;
    304304                                }
    305                                
     305
    306306                                result->triplet = *((vfs_triplet_t *) base);
    307307                                result->type = base->type;
    … …  
    316316                *result = res;
    317317        }
    318        
     318
    319319out:
    320320        plb_clear_entry(&entry, first, len);
    … …  
    339339        assert(base != NULL);
    340340        assert(path != NULL);
    341        
     341
    342342        size_t len;
    343343        errno_t rc;
    … …  
    348348        }
    349349        path = npath;
    350        
     350
    351351        assert(path[0] == '/');
    352352
    … …  
    367367                char *slash = str_rchr(path, L'/');
    368368                vfs_node_t *parent = base;
    369                
     369
    370370                if (slash != path) {
    371371                        int tflag = lflag;
    … …  
    392392                rc = _vfs_lookup_internal(base, path, lflag, result, len);
    393393        }
    394        
     394
    395395        return rc;
    396396}

  • uspace/srv/vfs/vfs_node.c

    r3061bc1 ra35b458  
    108108{
    109109        bool free_node = false;
    110        
    111         fibril_mutex_lock(&nodes_mutex);
    112        
     110
     111        fibril_mutex_lock(&nodes_mutex);
     112
    113113        node->refcnt--;
    114114        if (node->refcnt == 0) {
    … …  
    117117                 * Remove it from the VFS node hash table.
    118118                 */
    119                
     119
    120120                hash_table_remove_item(&nodes, &node->nh_link);
    121121                free_node = true;
    122122        }
    123        
    124         fibril_mutex_unlock(&nodes_mutex);
    125        
     123
     124        fibril_mutex_unlock(&nodes_mutex);
     125
    126126        if (free_node) {
    127127                /*
    … …  
    129129                 * are no more hard links.
    130130                 */
    131                
     131
    132132                async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
    133133                async_msg_2(exch, VFS_OUT_DESTROY, (sysarg_t) node->service_id,
    … …  
    239239            (node->service_id == rd->service_id))
    240240                rd->refcnt += node->refcnt;
    241        
     241
    242242        return true;
    243243}
    … …  
    268268{
    269269        async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
    270        
     270
    271271        ipc_call_t answer;
    272272        aid_t req = async_send_2(exch, VFS_OUT_OPEN_NODE,
    273273            (sysarg_t) node->service_id, (sysarg_t) node->index, &answer);
    274        
     274
    275275        vfs_exchange_release(exch);
    276276
    277277        errno_t rc;
    278278        async_wait_for(req, &rc);
    279        
     279
    280280        return rc;
    281281}
    … …  
    311311                .index = node->index
    312312        };
    313        
     313
    314314        return tri;
    315315}

  • uspace/srv/vfs/vfs_ops.c

    r3061bc1 ra35b458  
    6464{
    6565        size_t res = 0;
    66        
     66
    6767        while (a[res] == b[res] && a[res] != 0)
    6868                res++;
    69        
     69
    7070        if (a[res] == b[res])
    7171                return res;
    72        
     72
    7373        res--;
    7474        while (a[res] != '/')
    … …  
    9393        if (oldfd == newfd)
    9494                return EOK;
    95        
     95
    9696        /* Lookup the file structure corresponding to fd. */
    9797        vfs_file_t *oldfile = vfs_file_get(oldfd);
    … …  
    112112                        newfile->permissions = oldfile->permissions;
    113113                        vfs_node_addref(newfile->node);
    114        
     114
    115115                        vfs_file_put(newfile);
    116116                }
    117117        }
    118118        vfs_file_put(oldfile);
    119        
     119
    120120        return rc;
    121121}
    … …  
    131131{
    132132        fs_handle_t fs_handle = 0;
    133        
     133
    134134        fibril_mutex_lock(&fs_list_lock);
    135135        while (true) {
    136136                fs_handle = fs_name_to_handle(instance, fsname, false);
    137                
     137
    138138                if (fs_handle != 0 || !(flags & VFS_MOUNT_BLOCKING))
    139139                        break;
    140                
     140
    141141                fibril_condvar_wait(&fs_list_cv, &fs_list_lock);
    142142        }
    … …  
    145145        if (fs_handle == 0)
    146146                return ENOFS;
    147        
     147
    148148        /* Tell the mountee that it is being mounted. */
    149149        ipc_call_t answer;
    … …  
    164164                return rc;
    165165        }
    166        
     166
    167167        vfs_lookup_res_t res;
    168168        res.triplet.fs_handle = fs_handle;
    … …  
    172172            IPC_GET_ARG3(answer));
    173173        res.type = VFS_NODE_DIRECTORY;
    174        
     174
    175175        /* Add reference to the mounted root. */
    176176        *root = vfs_node_get(&res);
    … …  
    182182                return ENOMEM;
    183183        }
    184                        
     184
    185185        vfs_exchange_release(exch);
    186186
    … …  
    194194        errno_t rc;
    195195        errno_t retval;
    196        
     196
    197197        fibril_mutex_lock(&fs_list_lock);
    198198        fs_handle = fs_name_to_handle(0, fs_name, false);
    199199        fibril_mutex_unlock(&fs_list_lock);
    200        
     200
    201201        if (fs_handle == 0)
    202202                return ENOFS;
    203        
     203
    204204        /* Send probe request to the file system server */
    205205        ipc_call_t answer;
    … …  
    209209        if (msg == 0)
    210210                return EINVAL;
    211        
     211
    212212        /* Read probe information */
    213213        retval = async_data_read_start(exch, info, sizeof(*info));
    … …  
    216216                return retval;
    217217        }
    218        
     218
    219219        async_wait_for(msg, &rc);
    220220        vfs_exchange_release(exch);
    … …  
    229229        vfs_file_t *file = NULL;
    230230        *out_fd = -1;
    231        
     231
    232232        if (!(flags & VFS_MOUNT_CONNECT_ONLY)) {
    233233                mp = vfs_file_get(mpfd);
    … …  
    236236                        goto out;
    237237                }
    238                
     238
    239239                if (mp->node->mount != NULL) {
    240240                        rc = EBUSY;
    241241                        goto out;
    242242                }
    243                
     243
    244244                if (mp->node->type != VFS_NODE_DIRECTORY) {
    245245                        rc = ENOTDIR;
    246246                        goto out;
    247247                }
    248                
     248
    249249                if (vfs_node_has_children(mp->node)) {
    250250                        rc = ENOTEMPTY;
    … …  
    252252                }
    253253        }
    254        
     254
    255255        if (!(flags & VFS_MOUNT_NO_REF)) {
    256256                rc = vfs_fd_alloc(&file, false, out_fd);
    … …  
    259259                }
    260260        }
    261        
     261
    262262        vfs_node_t *root = NULL;
    263        
     263
    264264        fibril_rwlock_write_lock(&namespace_rwlock);
    265265
    … …  
    271271                mp->node->mount = root;
    272272        }
    273        
     273
    274274        fibril_rwlock_write_unlock(&namespace_rwlock);
    275        
     275
    276276        if (rc != EOK)
    277277                goto out;
    278        
     278
    279279        if (flags & VFS_MOUNT_NO_REF) {
    280280                vfs_node_delref(root);
    281281        } else {
    282282                assert(file != NULL);
    283                
     283
    284284                file->node = root;
    285285                file->permissions = MODE_READ | MODE_WRITE | MODE_APPEND;
    … …  
    287287                file->open_write = false;
    288288        }
    289        
     289
    290290out:
    291291        if (mp)
    … …  
    298298                *out_fd = -1;
    299299        }
    300        
     300
    301301        return rc;
    302302}
    … …  
    310310        if (!file)
    311311                return EBADF;
    312        
     312
    313313        if ((mode & ~file->permissions) != 0) {
    314314                vfs_file_put(file);
    315315                return EPERM;
    316316        }
    317        
     317
    318318        if (file->open_read || file->open_write) {
    319319                vfs_file_put(file);
    320320                return EBUSY;
    321321        }
    322        
     322
    323323        file->open_read = (mode & MODE_READ) != 0;
    324324        file->open_write = (mode & (MODE_WRITE | MODE_APPEND)) != 0;
    325325        file->append = (mode & MODE_APPEND) != 0;
    326        
     326
    327327        if (!file->open_read && !file->open_write) {
    328328                vfs_file_put(file);
    329329                return EINVAL;
    330330        }
    331        
     331
    332332        if (file->node->type == VFS_NODE_DIRECTORY && file->open_write) {
    333333                file->open_read = file->open_write = false;
    … …  
    335335                return EINVAL;
    336336        }
    337        
     337
    338338        errno_t rc = vfs_open_node_remote(file->node);
    339339        if (rc != EOK) {
    … …  
    342342                return rc;
    343343        }
    344        
     344
    345345        vfs_file_put(file);
    346346        return EOK;
    … …  
    385385        if (exch == NULL)
    386386                return ENOENT;
    387        
     387
    388388        aid_t msg = async_send_fast(exch, read ? VFS_OUT_READ : VFS_OUT_WRITE,
    389389            file->node->service_id, file->node->index, LOWER32(pos),
    … …  
    397397                return retval;
    398398        }
    399        
     399
    400400        errno_t rc;
    401401        async_wait_for(msg, &rc);
    402        
     402
    403403        chunk->size = IPC_GET_ARG1(*answer);
    404404
    … …  
    418418         * open files supports parallel access!
    419419         */
    420        
     420
    421421        /* Lookup the file structure corresponding to the file descriptor. */
    422422        vfs_file_t *file = vfs_file_get(fd);
    423423        if (!file)
    424424                return EBADF;
    425        
     425
    426426        if ((read && !file->open_read) || (!read && !file->open_write)) {
    427427                vfs_file_put(file);
    428428                return EINVAL;
    429429        }
    430        
     430
    431431        vfs_info_t *fs_info = fs_handle_to_info(file->node->fs_handle);
    432432        assert(fs_info);
    433        
     433
    434434        bool rlock = read ||
    435435            (fs_info->concurrent_read_write && fs_info->write_retains_size);
    436        
     436
    437437        /*
    438438         * Lock the file's node so that no other client can read/write to it at
    … …  
    444444        else
    445445                fibril_rwlock_write_lock(&file->node->contents_rwlock);
    446        
     446
    447447        if (file->node->type == VFS_NODE_DIRECTORY) {
    448448                /*
    … …  
    450450                 * while we are in readdir().
    451451                 */
    452                
     452
    453453                if (!read) {
    454454                        if (rlock) {
    … …  
    462462                        return EINVAL;
    463463                }
    464                
     464
    465465                fibril_rwlock_read_lock(&namespace_rwlock);
    466466        }
    467        
     467
    468468        async_exch_t *fs_exch = vfs_exchange_grab(file->node->fs_handle);
    469        
     469
    470470        if (!read && file->append)
    471471                pos = file->node->size;
    472        
     472
    473473        /*
    474474         * Handle communication with the endpoint FS.
    … …  
    476476        ipc_call_t answer;
    477477        errno_t rc = ipc_cb(fs_exch, file, pos, &answer, read, ipc_cb_data);
    478        
     478
    479479        vfs_exchange_release(fs_exch);
    480        
     480
    481481        if (file->node->type == VFS_NODE_DIRECTORY)
    482482                fibril_rwlock_read_unlock(&namespace_rwlock);
    483        
     483
    484484        /* Unlock the VFS node. */
    485485        if (rlock) {
    … …  
    493493                fibril_rwlock_write_unlock(&file->node->contents_rwlock);
    494494        }
    495        
     495
    496496        vfs_file_put(file);
    497497
    … …  
    518518        vfs_node_addref(base);
    519519        vfs_file_put(base_file);
    520        
     520
    521521        vfs_lookup_res_t base_lr;
    522522        vfs_lookup_res_t old_lr;
    523523        vfs_lookup_res_t new_lr_orig;
    524524        bool orig_unlinked = false;
    525        
     525
    526526        errno_t rc;
    527        
     527
    528528        size_t shared = shared_path(old, new);
    529        
     529
    530530        /* Do not allow one path to be a prefix of the other. */
    531531        if (old[shared] == 0 || new[shared] == 0) {
    … …  
    535535        assert(old[shared] == '/');
    536536        assert(new[shared] == '/');
    537        
     537
    538538        fibril_rwlock_write_lock(&namespace_rwlock);
    539        
     539
    540540        /* Resolve the shared portion of the path first. */
    541541        if (shared != 0) {
    … …  
    547547                        return rc;
    548548                }
    549                
     549
    550550                vfs_node_put(base);
    551551                base = vfs_node_get(&base_lr);
    … …  
    565565                return rc;
    566566        }
    567                
     567
    568568        rc = vfs_lookup_internal(base, new, L_UNLINK | L_DISABLE_MOUNTS,
    569569            &new_lr_orig);
    … …  
    595595                return rc;
    596596        }
    597        
     597
    598598        /* If the node is not held by anyone, try to destroy it. */
    599599        if (orig_unlinked) {
    … …  
    604604                        vfs_node_put(node);
    605605        }
    606        
     606
    607607        vfs_node_put(base);
    608608        fibril_rwlock_write_unlock(&namespace_rwlock);
    … …  
    617617
    618618        fibril_rwlock_write_lock(&file->node->contents_rwlock);
    619        
     619
    620620        errno_t rc = vfs_truncate_internal(file->node->fs_handle,
    621621            file->node->service_id, file->node->index, size);
    622622        if (rc == EOK)
    623623                file->node->size = size;
    624        
     624
    625625        fibril_rwlock_write_unlock(&file->node->contents_rwlock);
    626626        vfs_file_put(file);
    … …  
    640640            node->service_id, node->index, true, 0, NULL);
    641641        vfs_exchange_release(exch);
    642        
     642
    643643        vfs_file_put(file);
    644644        return rc;
    … …  
    667667        if (!file)
    668668                return EBADF;
    669        
     669
    670670        async_exch_t *fs_exch = vfs_exchange_grab(file->node->fs_handle);
    671        
     671
    672672        aid_t msg;
    673673        ipc_call_t answer;
    674674        msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->service_id,
    675675            file->node->index, &answer);
    676        
     676
    677677        vfs_exchange_release(fs_exch);
    678        
     678
    679679        errno_t rc;
    680680        async_wait_for(msg, &rc);
    681        
     681
    682682        vfs_file_put(file);
    683683        return rc;
    684        
     684
    685685}
    686686
    … …  
    693693            UPPER32(size));
    694694        vfs_exchange_release(exch);
    695        
     695
    696696        return (errno_t) rc;
    697697}
    … …  
    702702        vfs_file_t *parent = NULL;
    703703        vfs_file_t *expect = NULL;
    704        
     704
    705705        if (parentfd == expectfd)
    706706                return EINVAL;
    707        
     707
    708708        fibril_rwlock_write_lock(&namespace_rwlock);
    709        
     709
    710710        /*
    711711         * Files are retrieved in order of file descriptors, to prevent
    … …  
    719719                }
    720720        }
    721        
     721
    722722        if (expectfd >= 0) {
    723723                expect = vfs_file_get(expectfd);
    … …  
    727727                }
    728728        }
    729        
     729
    730730        if (parentfd > expectfd) {
    731731                parent = vfs_file_get(parentfd);
    … …  
    735735                }
    736736        }
    737        
     737
    738738        assert(parent != NULL);
    739        
     739
    740740        if (expectfd >= 0) {
    741741                vfs_lookup_res_t lr;
    … …  
    743743                if (rc != EOK)
    744744                        goto exit;
    745                
     745
    746746                vfs_node_t *found_node = vfs_node_peek(&lr);
    747747                vfs_node_put(found_node);
    … …  
    750750                        goto exit;
    751751                }
    752                
     752
    753753                vfs_file_put(expect);
    754754                expect = NULL;
    755755        }
    756        
     756
    757757        vfs_lookup_res_t lr;
    758758        rc = vfs_lookup_internal(parent->node, path, L_UNLINK, &lr);
    … …  
    783783        if (mp == NULL)
    784784                return EBADF;
    785        
     785
    786786        if (mp->node->mount == NULL) {
    787787                vfs_file_put(mp);
    788788                return ENOENT;
    789789        }
    790        
     790
    791791        fibril_rwlock_write_lock(&namespace_rwlock);
    792        
     792
    793793        /*
    794794         * Count the total number of references for the mounted file system. We
    … …  
    804804                return EBUSY;
    805805        }
    806        
     806
    807807        async_exch_t *exch = vfs_exchange_grab(mp->node->mount->fs_handle);
    808808        errno_t rc = async_req_1_0(exch, VFS_OUT_UNMOUNTED,
    809809            mp->node->mount->service_id);
    810810        vfs_exchange_release(exch);
    811        
     811
    812812        if (rc != EOK) {
    813813                vfs_file_put(mp);
    … …  
    815815                return rc;
    816816        }
    817        
     817
    818818        vfs_node_forget(mp->node->mount);
    819819        vfs_node_put(mp->node);
    820820        mp->node->mount = NULL;
    821        
     821
    822822        fibril_rwlock_write_unlock(&namespace_rwlock);
    823        
     823
    824824        vfs_file_put(mp);
    825825        return EOK;
    … …  
    866866        if (!walk_flags_valid(flags))
    867867                return EINVAL;
    868        
     868
    869869        vfs_file_t *parent = vfs_file_get(parentfd);
    870870        if (!parent)
    871871                return EBADF;
    872        
     872
    873873        fibril_rwlock_read_lock(&namespace_rwlock);
    874        
     874
    875875        vfs_lookup_res_t lr;
    876876        errno_t rc = vfs_lookup_internal(parent->node, path,
    … …  
    881881                return rc;
    882882        }
    883        
     883
    884884        vfs_node_t *node = vfs_node_get(&lr);
    885885        if (!node) {
    … …  
    888888                return ENOMEM;
    889889        }
    890        
     890
    891891        vfs_file_t *file;
    892892        rc = vfs_fd_alloc(&file, false, out_fd);
    … …  
    897897        }
    898898        assert(file != NULL);
    899        
     899
    900900        file->node = node;
    901901        file->permissions = parent->permissions;
    902902        file->open_read = false;
    903903        file->open_write = false;
    904        
     904
    905905        vfs_file_put(file);
    906906        vfs_file_put(parent);
    907        
     907
    908908        fibril_rwlock_read_unlock(&namespace_rwlock);
    909909

  • uspace/srv/vfs/vfs_register.c

    r3061bc1 ra35b458  
    7171{
    7272        int i;
    73        
     73
    7474        /*
    7575         * Check if the name is non-empty and is composed solely of ASCII
    … …  
    8080                return false;
    8181        }
    82        
     82
    8383        for (i = 1; i < FS_NAME_MAXLEN; i++) {
    8484                if (!(islower(info->name[i]) || isdigit(info->name[i])) &&
    … …  
    9393                }
    9494        }
    95        
     95
    9696        /*
    9797         * This check is not redundant. It ensures that the name is
    … …  
    102102                return false;
    103103        }
    104        
     104
    105105        return true;
    106106}
    … …  
    116116        dprintf("Processing VFS_REGISTER request received from %zx.\n",
    117117            request->in_phone_hash);
    118        
     118
    119119        vfs_info_t *vfs_info;
    120120        errno_t rc = async_data_write_accept((void **) &vfs_info, false,
    121121            sizeof(vfs_info_t), sizeof(vfs_info_t), 0, NULL);
    122        
     122
    123123        if (rc != EOK) {
    124124                dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
    … …  
    127127                return;
    128128        }
    129        
     129
    130130        /*
    131131         * Allocate and initialize a buffer for the fs_info structure.
    … …  
    137137                return;
    138138        }
    139        
     139
    140140        link_initialize(&fs_info->fs_link);
    141141        fs_info->vfs_info = *vfs_info;
    142142        free(vfs_info);
    143        
     143
    144144        dprintf("VFS info delivered.\n");
    145        
     145
    146146        if (!vfs_info_sane(&fs_info->vfs_info)) {
    147147                free(fs_info);
    … …  
    149149                return;
    150150        }
    151        
     151
    152152        fibril_mutex_lock(&fs_list_lock);
    153        
     153
    154154        /*
    155155         * Check for duplicit registrations.
    … …  
    166166                return;
    167167        }
    168        
     168
    169169        /*
    170170         * Add fs_info to the list of registered FS's.
    … …  
    172172        dprintf("Inserting FS into the list of registered file systems.\n");
    173173        list_append(&fs_info->fs_link, &fs_list);
    174        
     174
    175175        /*
    176176         * Now we want the client to send us the IPC_M_CONNECT_TO_ME call so
    … …  
    187187                return;
    188188        }
    189        
     189
    190190        dprintf("Callback connection to FS created.\n");
    191        
     191
    192192        /*
    193193         * The client will want us to send him the address space area with PLB.
    194194         */
    195        
     195
    196196        size_t size;
    197197        ipc_callid_t callid;
    … …  
    206206                return;
    207207        }
    208        
     208
    209209        /*
    210210         * We can only send the client address space area PLB_SIZE bytes long.
    … …  
    220220                return;
    221221        }
    222        
     222
    223223        /*
    224224         * Commit to read-only sharing the PLB with the client.
    … …  
    226226        (void) async_share_in_finalize(callid, plb,
    227227            AS_AREA_READ | AS_AREA_CACHEABLE);
    228        
     228
    229229        dprintf("Sharing PLB.\n");
    230        
     230
    231231        /*
    232232         * That was it. The FS has been registered.
    … …  
    236236        fs_info->fs_handle = (fs_handle_t) atomic_postinc(&fs_handle_next);
    237237        async_answer_1(rid, EOK, (sysarg_t) fs_info->fs_handle);
    238        
     238
    239239        fibril_condvar_broadcast(&fs_list_cv);
    240240        fibril_mutex_unlock(&fs_list_lock);
    241        
     241
    242242        dprintf("\"%.*s\" filesystem successfully registered, handle=%d.\n",
    243243            FS_NAME_MAXLEN, fs_info->vfs_info.name, fs_info->fs_handle);
    … …  
    260260         */
    261261        fibril_mutex_lock(&fs_list_lock);
    262        
     262
    263263        list_foreach(fs_list, fs_link, fs_info_t, fs) {
    264264                if (fs->fs_handle == handle) {
    265265                        fibril_mutex_unlock(&fs_list_lock);
    266                        
     266
    267267                        assert(fs->sess);
    268268                        async_exch_t *exch = async_exchange_begin(fs->sess);
    269                        
     269
    270270                        assert(exch);
    271271                        return exch;
    272272                }
    273273        }
    274        
     274
    275275        fibril_mutex_unlock(&fs_list_lock);
    276        
     276
    277277        return NULL;
    278278}
    … …  
    300300{
    301301        int handle = 0;
    302        
     302
    303303        if (lock)
    304304                fibril_mutex_lock(&fs_list_lock);
    305        
     305
    306306        list_foreach(fs_list, fs_link, fs_info_t, fs) {
    307307                if (str_cmp(fs->vfs_info.name, name) == 0 &&
    … …  
    311311                }
    312312        }
    313        
     313
    314314        if (lock)
    315315                fibril_mutex_unlock(&fs_list_lock);
    316        
     316
    317317        return handle;
    318318}
    … …  
    328328{
    329329        vfs_info_t *info = NULL;
    330        
     330
    331331        fibril_mutex_lock(&fs_list_lock);
    332332        list_foreach(fs_list, fs_link, fs_info_t, fs) {
    … …  
    337337        }
    338338        fibril_mutex_unlock(&fs_list_lock);
    339        
     339
    340340        return info;
    341341}
    … …  
    355355
    356356        fibril_mutex_lock(&fs_list_lock);
    357        
     357
    358358        size = 0;
    359359        count = 0;
    … …  
    362362                count++;
    363363        }
    364        
     364
    365365        if (size == 0)
    366366                size = 1;
    367        
     367
    368368        fstypes->buf = calloc(1, size);
    369369        if (fstypes->buf == NULL) {
    … …  
    371371                return ENOMEM;
    372372        }
    373        
     373
    374374        fstypes->fstypes = calloc(sizeof(char *), count);
    375375        if (fstypes->fstypes == NULL) {
    … …  
    379379                return ENOMEM;
    380380        }
    381        
     381
    382382        fstypes->size = size;
    383        
     383
    384384        size = 0; count = 0;
    385385        list_foreach(fs_list, fs_link, fs_info_t, fs) {
Note: See TracChangeset for help on using the changeset viewer.