Changeset 61042de in mainline for uspace/srv/vfs


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

Location:
uspace/srv/vfs
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_lookup.c

    rb7f69f2 r61042de  
    4949#include <assert.h>
    5050
    51 #define DPRINTF(...)
    52 
    53 #define min(a, b)  ((a) < (b) ? (a) : (b))
    54 
    5551FIBRIL_MUTEX_INITIALIZE(plb_mutex);
    5652LIST_INITIALIZE(plb_entries);   /**< PLB entry ring buffer. */
    5753uint8_t *plb = NULL;
    5854
    59 static int plb_insert_entry(plb_entry_t *entry, char *path, size_t *start, size_t len)
     55static int plb_insert_entry(plb_entry_t *entry, char *path, size_t *start,
     56    size_t len)
    6057{
    6158        fibril_mutex_lock(&plb_mutex);
    … …  
    174171               
    175172                rc = vfs_lookup_internal(base, path, L_DIRECTORY, &res);
    176                 if (rc != EOK) {
     173                if (rc != EOK)
    177174                        goto out;
    178                 }
    179175                triplet = &res.triplet;
    180176               
    … …  
    190186        }
    191187       
    192         if (triplet->fs_handle != child->fs_handle || triplet->service_id != child->service_id) {
     188        if (triplet->fs_handle != child->fs_handle ||
     189            triplet->service_id != child->service_id) {
    193190                rc = EXDEV;
    194191                goto out;
    … …  
    196193       
    197194        async_exch_t *exch = vfs_exchange_grab(triplet->fs_handle);
    198         aid_t req = async_send_3(exch, VFS_OUT_LINK, triplet->service_id, triplet->index, child->index, NULL);
     195        aid_t req = async_send_3(exch, VFS_OUT_LINK, triplet->service_id,
     196            triplet->index, child->index, NULL);
    199197       
    200198        rc = async_data_write_start(exch, component, str_size(component) + 1);
    … …  
    202200        async_wait_for(req, &orig_rc);
    203201        vfs_exchange_release(exch);
    204         if (orig_rc != EOK) {
     202        if (orig_rc != EOK)
    205203                rc = orig_rc;
    206         }
    207204       
    208205out:
    209         DPRINTF("vfs_link_internal() with path '%s' returns %d\n", path, rc);
    210206        return rc;
    211207}
    212208
    213209static int out_lookup(vfs_triplet_t *base, size_t *pfirst, size_t *plen,
    214         int lflag, vfs_lookup_res_t *result)
     210    int lflag, vfs_lookup_res_t *result)
    215211{
    216212        assert(base);
    … …  
    220216        ipc_call_t answer;
    221217        async_exch_t *exch = vfs_exchange_grab(base->fs_handle);
    222         aid_t req = async_send_5(exch, VFS_OUT_LOOKUP, (sysarg_t) *pfirst, (sysarg_t) *plen,
    223             (sysarg_t) base->service_id, (sysarg_t) base->index, (sysarg_t) lflag, &answer);
     218        aid_t req = async_send_5(exch, VFS_OUT_LOOKUP, (sysarg_t) *pfirst,
     219            (sysarg_t) *plen, (sysarg_t) base->service_id,
     220            (sysarg_t) base->index, (sysarg_t) lflag, &answer);
    224221        async_wait_for(req, &rc);
    225222        vfs_exchange_release(exch);
    226223       
    227         if ((int) rc < 0) {
     224        if ((int) rc < 0)
    228225                return (int) rc;
    229         }
    230226       
    231227        unsigned last = *pfirst + *plen;
    … …  
    237233        result->triplet.index = (fs_index_t) IPC_GET_ARG2(answer);
    238234        result->size = (int64_t)(int32_t) IPC_GET_ARG4(answer);
    239         result->type = IPC_GET_ARG5(answer) ? VFS_NODE_DIRECTORY : VFS_NODE_FILE;
     235        result->type = IPC_GET_ARG5(answer) ?
     236            VFS_NODE_DIRECTORY : VFS_NODE_FILE;
    240237        return EOK;
    241238}
    … …  
    253250 *
    254251 */
    255 int vfs_lookup_internal(vfs_node_t *base, char *path, int lflag, vfs_lookup_res_t *result)
     252int vfs_lookup_internal(vfs_node_t *base, char *path, int lflag,
     253    vfs_lookup_res_t *result)
    256254{
    257255        assert(base != NULL);
    … …  
    262260        char *npath = canonify(path, &len);
    263261        if (!npath) {
    264                 DPRINTF("vfs_lookup_internal() can't canonify path: %s\n", path);
    265262                rc = EINVAL;
    266263                return rc;
    … …  
    274271        plb_entry_t entry;
    275272        rc = plb_insert_entry(&entry, path, &first, len);
    276         if (rc != EOK) {
    277                 DPRINTF("vfs_lookup_internal() can't insert entry into PLB: %d\n", rc);
     273        if (rc != EOK)
    278274                return rc;
    279         }
    280275       
    281276        size_t next = first;
    … …  
    286281        /* Resolve path as long as there are mount points to cross. */
    287282        while (nlen > 0) {
    288                 while (base->mount != NULL) {
     283                while (base->mount) {
    289284                        if (lflag & L_DISABLE_MOUNTS) {
    290285                                rc = EXDEV;
    … …  
    295290                }
    296291               
    297                 rc = out_lookup((vfs_triplet_t *) base, &next, &nlen, lflag, &res);
    298                 if (rc != EOK) {
     292                rc = out_lookup((vfs_triplet_t *) base, &next, &nlen, lflag,
     293                    &res);
     294                if (rc != EOK)
    299295                        goto out;
    300                 }
    301296               
    302297                if (nlen > 0) {
    … …  
    349344out:
    350345        plb_clear_entry(&entry, first, len);
    351         DPRINTF("vfs_lookup_internal() with path '%s' returns %d\n", path, rc);
    352346        return rc;
    353347}

  • uspace/srv/vfs/vfs_node.c

    rb7f69f2 r61042de  
    113113        node->refcnt--;
    114114        if (node->refcnt == 0) {
    115                
    116115                /*
    117116                 * We are dropping the last reference to this node.
    … …  
    127126        if (free_node) {
    128127                /*
    129                  * DESTROY will free up the file's resources if there are no more hard links.
     128                 * VFS_OUT_DESTROY will free up the file's resources if there
     129                 * are no more hard links.
    130130                 */
    131131               
    132132                async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
    133                 async_msg_2(exch, VFS_OUT_DESTROY,
    134                         (sysarg_t) node->service_id, (sysarg_t)node->index);
     133                async_msg_2(exch, VFS_OUT_DESTROY, (sysarg_t) node->service_id,
     134                    (sysarg_t)node->index);
    135135                vfs_exchange_release(exch);
    136136
    … …  
    300300        vfs_triplet_t *tri = key;
    301301        vfs_node_t *node = hash_table_get_inst(item, vfs_node_t, nh_link);
    302         return node->fs_handle == tri->fs_handle
    303                 && node->service_id == tri->service_id
    304                 && node->index == tri->index;
     302        return node->fs_handle == tri->fs_handle &&
     303            node->service_id == tri->service_id && node->index == tri->index;
    305304}
    306305
    … …  
    323322               
    324323                async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
    325                 (void) async_req_2_2(exch, VFS_OUT_GET_SIZE,
    326                         node->service_id, node->index, &sz1, &sz2);
     324                (void) async_req_2_2(exch, VFS_OUT_GET_SIZE, node->service_id,
     325                    node->index, &sz1, &sz2);
    327326                vfs_exchange_release(exch);
    328327               
    … …  
    335334{
    336335        async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
    337         int rc = async_req_2_0(exch, VFS_OUT_IS_EMPTY, node->service_id, node->index);
     336        int rc = async_req_2_0(exch, VFS_OUT_IS_EMPTY, node->service_id,
     337            node->index);
    338338        vfs_exchange_release(exch);
    339339        return rc == ENOTEMPTY;

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