Changeset 61042de in mainline for uspace/srv/vfs/vfs_ops.c


Ignore:
Timestamp:
2017-03-18T20:58:08Z (8 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
61600e7
Parents:
b7f69f2
Message:

Cstyle and clutter removal

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    rb7f69f2 r61042de  
    6767        size_t res = 0;
    6868       
    69         while (a[res] == b[res] && a[res] != 0) {
     69        while (a[res] == b[res] && a[res] != 0)
    7070                res++;
    71         }
    72        
    73         if (a[res] == b[res]) {
     71       
     72        if (a[res] == b[res])
    7473                return res;
    75         }
    7674       
    7775        res--;
    78         while (a[res] != '/') {
     76        while (a[res] != '/')
    7977                res--;
    80         }
    8178        return res;
    8279}
    … …  
    8683{
    8784        async_exch_t *exch = vfs_exchange_grab(file->fs_handle);
    88         async_msg_2(exch, VFS_OUT_DESTROY,
    89                 (sysarg_t) file->service_id, (sysarg_t) file->index);
     85        async_msg_2(exch, VFS_OUT_DESTROY, (sysarg_t) file->service_id,
     86            (sysarg_t) file->index);
    9087        vfs_exchange_release(exch);
    9188}
    … …  
    9592        /* Lookup the file structure corresponding to fd. */
    9693        vfs_file_t *oldfile = vfs_file_get(oldfd);
    97         if (oldfile == NULL) {
    98                 return EBADF;
    99         }
     94        if (oldfile == NULL)
     95                return EBADF;
     96
    10097        assert(oldfile->node != NULL);
    10198       
    … …  
    122119{
    123120        /* If the file descriptors are the same, do nothing. */
    124         if (oldfd == newfd) {
     121        if (oldfd == newfd)
    125122                return EOK;
    126         }
    127123       
    128124        /* Lookup the file structure corresponding to oldfd. */
    129125        vfs_file_t *oldfile = vfs_file_get(oldfd);
    130         if (!oldfile) {
    131                 return EBADF;
    132         }
     126        if (!oldfile)
     127                return EBADF;
    133128       
    134129        /* Make sure newfd is closed. */
    … …  
    145140{
    146141        vfs_file_t *file = vfs_file_get(fd);
    147         if (!file) {
    148                 return EBADF;
    149         }
     142        if (!file)
     143                return EBADF;
     144
    150145        assert(file->node);
    151146       
    … …  
    182177       
    183178        fibril_mutex_lock(&fs_list_lock);
    184         while (1) {
     179        while (true) {
    185180                fs_handle = fs_name_to_handle(instance, fsname, false);
    186181               
    187                 if (fs_handle != 0 || !(flags & VFS_MOUNT_BLOCKING)) {
     182                if (fs_handle != 0 || !(flags & VFS_MOUNT_BLOCKING))
    188183                        break;
    189                 }
    190184               
    191185                fibril_condvar_wait(&fs_list_cv, &fs_list_lock);
    … …  
    193187        fibril_mutex_unlock(&fs_list_lock);
    194188
    195         if (fs_handle == 0) {
     189        if (fs_handle == 0)
    196190                return ENOENT;
    197         }
    198191       
    199192        /* Tell the mountee that it is being mounted. */
    … …  
    212205        vfs_exchange_release(exch);
    213206       
    214         if (rc != EOK) {
     207        if (rc != EOK)
    215208                return rc;
    216         }
    217209       
    218210        vfs_lookup_res_t res;
    … …  
    284276        fibril_rwlock_write_unlock(&namespace_rwlock);
    285277       
    286         if (rc != EOK) {
     278        if (rc != EOK)
    287279                goto out;
    288         }
    289280       
    290281        if (flags & VFS_MOUNT_NO_REF) {
    … …  
    300291       
    301292out:
    302         if (mp) {
     293        if (mp)
    303294                vfs_file_put(mp);
    304         }
    305         if (file) {
    306                 vfs_file_put(file);
    307         }
     295        if (file)
     296                vfs_file_put(file);
     297
    308298        if (rc != EOK && fd >= 0) {
    309299                vfs_fd_free(fd);
    … …  
    317307int vfs_op_open2(int fd, int flags)
    318308{
    319         if (flags == 0) {
     309        if (flags == 0)
    320310                return EINVAL;
    321         }
    322311
    323312        vfs_file_t *file = vfs_file_get(fd);
    324         if (!file) {
    325                 return EBADF;
    326         }
     313        if (!file)
     314                return EBADF;
    327315       
    328316        if ((flags & ~file->permissions) != 0) {
    … …  
    454442         * write implementation does not modify the file size.
    455443         */
    456         if (rlock) {
     444        if (rlock)
    457445                fibril_rwlock_read_lock(&file->node->contents_rwlock);
    458         } else {
     446        else
    459447                fibril_rwlock_write_lock(&file->node->contents_rwlock);
    460         }
    461448       
    462449        if (file->node->type == VFS_NODE_DIRECTORY) {
    … …  
    496483        size_t bytes = IPC_GET_ARG1(answer);
    497484       
    498         if (file->node->type == VFS_NODE_DIRECTORY) {
     485        if (file->node->type == VFS_NODE_DIRECTORY)
    499486                fibril_rwlock_read_unlock(&namespace_rwlock);
    500         }
    501487       
    502488        /* Unlock the VFS node. */
    … …  
    513499       
    514500        /* Update the position pointer and unlock the open file. */
    515         if (rc == EOK) {
     501        if (rc == EOK)
    516502                file->pos += bytes;
    517         }
    518503        vfs_file_put(file);     
    519504
    … …  
    534519{
    535520        vfs_file_t *base_file = vfs_file_get(basefd);
    536         if (!base_file) {
    537                 return EBADF;
    538         }
     521        if (!base_file)
     522                return EBADF;
     523
    539524        vfs_node_t *base = base_file->node;
    540525        vfs_node_addref(base);
    … …  
    577562        }
    578563
    579         rc = vfs_lookup_internal(base, old, L_DISABLE_MOUNTS,
    580             &old_lr);
     564        rc = vfs_lookup_internal(base, old, L_DISABLE_MOUNTS, &old_lr);
    581565        if (rc != EOK) {
    582566                vfs_node_put(base);
    … …  
    598582        if (rc != EOK) {
    599583                vfs_link_internal(base, old, &old_lr.triplet);
    600                 if (orig_unlinked) {
     584                if (orig_unlinked)
    601585                        vfs_link_internal(base, new, &new_lr_orig.triplet);
    602                 }
    603586                vfs_node_put(base);
    604587                fibril_rwlock_write_unlock(&namespace_rwlock);
    … …  
    609592            &old_lr);
    610593        if (rc != EOK) {
    611                 if (orig_unlinked) {
     594                if (orig_unlinked)
    612595                        vfs_link_internal(base, new, &new_lr_orig.triplet);
    613                 }
    614596                vfs_node_put(base);
    615597                fibril_rwlock_write_unlock(&namespace_rwlock);
    … …  
    634616{
    635617        vfs_file_t *file = vfs_file_get(fd);
    636         if (!file) {
    637                 return EBADF;
    638         }
     618        if (!file)
     619                return EBADF;
    639620       
    640621        switch (whence) {
    … …  
    724705{
    725706        vfs_file_t *file = vfs_file_get(fd);
    726         if (!file) {
    727                 return EBADF;
    728         }
     707        if (!file)
     708                return EBADF;
    729709       
    730710        async_exch_t *fs_exch = vfs_exchange_grab(file->node->fs_handle);
    … …  
    733713        ipc_call_t answer;
    734714        msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->service_id,
    735                 file->node->index, &answer);
     715            file->node->index, &answer);
    736716       
    737717        vfs_exchange_release(fs_exch);
    … …  
    760740{
    761741        vfs_file_t *file = vfs_file_get(fd);
    762         if (!file) {
    763                 return EBADF;
    764         }
     742        if (!file)
     743                return EBADF;
    765744
    766745        fibril_rwlock_write_lock(&file->node->contents_rwlock);
    767746       
    768747        int rc = vfs_truncate_internal(file->node->fs_handle,
    769                 file->node->service_id, file->node->index, size);
    770         if (rc == EOK) {
     748            file->node->service_id, file->node->index, size);
     749        if (rc == EOK)
    771750                file->node->size = size;
    772         }
    773751       
    774752        fibril_rwlock_write_unlock(&file->node->contents_rwlock);
    … …  
    783761        vfs_file_t *expect = NULL;
    784762       
    785         if (parentfd == expectfd) {
     763        if (parentfd == expectfd)
    786764                return EINVAL;
    787         }
    788765       
    789766        fibril_rwlock_write_lock(&namespace_rwlock);
    790767       
    791         int lflag = (wflag&WALK_DIRECTORY) ? L_DIRECTORY: 0;
     768        int lflag = (wflag & WALK_DIRECTORY) ? L_DIRECTORY: 0;
    792769
    793770        /*
    … …  
    824801                vfs_lookup_res_t lr;
    825802                rc = vfs_lookup_internal(parent->node, path, lflag, &lr);
    826                 if (rc != EOK) {
     803                if (rc != EOK)
    827804                        goto exit;
    828                 }
    829805               
    830806                vfs_node_t *found_node = vfs_node_peek(&lr);
    … …  
    841817        vfs_lookup_res_t lr;
    842818        rc = vfs_lookup_internal(parent->node, path, lflag | L_UNLINK, &lr);
    843         if (rc != EOK) {
     819        if (rc != EOK)
    844820                goto exit;
    845         }
    846821
    847822        /* If the node is not held by anyone, try to destroy it. */
    … …  
    853828
    854829exit:
    855         if (path) {
     830        if (path)
    856831                free(path);
    857         }
    858         if (parent) {
     832        if (parent)
    859833                vfs_file_put(parent);
    860         }
    861         if (expect) {
     834        if (expect)
    862835                vfs_file_put(expect);
    863         }
    864836        fibril_rwlock_write_unlock(&namespace_rwlock);
    865837        return rc;
    … …  
    869841{
    870842        vfs_file_t *mp = vfs_file_get(mpfd);
    871         if (mp == NULL) {
    872                 return EBADF;
    873         }
     843        if (mp == NULL)
     844                return EBADF;
    874845       
    875846        if (mp->node->mount == NULL) {
    … …  
    922893static inline bool walk_flags_valid(int flags)
    923894{
    924         if ((flags & ~WALK_ALL_FLAGS) != 0) {
     895        if ((flags & ~WALK_ALL_FLAGS) != 0)
    925896                return false;
    926         }
    927         if ((flags & WALK_MAY_CREATE) && (flags & WALK_MUST_CREATE)) {
     897        if ((flags & WALK_MAY_CREATE) && (flags & WALK_MUST_CREATE))
    928898                return false;
    929         }
    930         if ((flags & WALK_REGULAR) && (flags & WALK_DIRECTORY)) {
     899        if ((flags & WALK_REGULAR) && (flags & WALK_DIRECTORY))
    931900                return false;
    932         }
    933901        if ((flags & WALK_MAY_CREATE) || (flags & WALK_MUST_CREATE)) {
    934                 if (!(flags & WALK_DIRECTORY) && !(flags & WALK_REGULAR)) {
     902                if (!(flags & WALK_DIRECTORY) && !(flags & WALK_REGULAR))
    935903                        return false;
    936                 }
    937904        }
    938905        return true;
    … …  
    942909{
    943910        int lflags = 0;
    944         if ((flags & WALK_MAY_CREATE) || (flags & WALK_MUST_CREATE)) {
     911        if ((flags & WALK_MAY_CREATE) || (flags & WALK_MUST_CREATE))
    945912                lflags |= L_CREATE;
    946         }
    947         if (flags & WALK_MUST_CREATE) {
     913        if (flags & WALK_MUST_CREATE)
    948914                lflags |= L_EXCLUSIVE;
    949         }
    950         if (flags & WALK_REGULAR) {
     915        if (flags & WALK_REGULAR)
    951916                lflags |= L_FILE;
    952         }
    953         if (flags & WALK_DIRECTORY) {
     917        if (flags & WALK_DIRECTORY)
    954918                lflags |= L_DIRECTORY;
    955         }
    956         if (flags & WALK_MOUNT_POINT) {
     919        if (flags & WALK_MOUNT_POINT)
    957920                lflags |= L_MP;
    958         }
    959921        return lflags;
    960922}
    … …  
    962924int vfs_op_walk(int parentfd, int flags, char *path, int *out_fd)
    963925{
    964         if (!walk_flags_valid(flags)) {
     926        if (!walk_flags_valid(flags))
    965927                return EINVAL;
    966         }
    967928       
    968929        vfs_file_t *parent = vfs_file_get(parentfd);
    969         if (!parent) {
    970                 return EBADF;
    971         }
     930        if (!parent)
     931                return EBADF;
    972932       
    973933        fibril_rwlock_read_lock(&namespace_rwlock);
Note: See TracChangeset for help on using the changeset viewer.