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

Changeset 61042de in mainline


Ignore:
Timestamp:
2017-03-18T20:58:08Z (3 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
master
Children:
61600e7
Parents:
b7f69f2
Message:

Cstyle and clutter removal

Location:
uspace
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/vfs/vfs.c

    rb7f69f2 r61042de  
    7373        fibril_mutex_lock(&root_mutex);
    7474        int r;
    75         if (root_fd < 0) {
     75        if (root_fd < 0)
    7676                r = ENOENT;
    77         } else {
     77        else
    7878                r = vfs_clone(root_fd, true);
    79         }
    8079        fibril_mutex_unlock(&root_mutex);
    8180        return r;
     
    8584{
    8685        fibril_mutex_lock(&root_mutex);
    87         if (root_fd >= 0) {
     86        if (root_fd >= 0)
    8887                close(root_fd);
    89         }
    9088        root_fd = vfs_clone(nroot, true);
    9189        fibril_mutex_unlock(&root_mutex);
     
    10199        fibril_mutex_lock(&vfs_mutex);
    102100       
    103         while (vfs_sess == NULL)
     101        while (vfs_sess == NULL) {
    104102                vfs_sess = service_connect_blocking(SERVICE_VFS, INTERFACE_VFS,
    105103                    0);
     104        }
    106105       
    107106        fibril_mutex_unlock(&vfs_mutex);
     
    132131        async_wait_for(req, &rc_orig);
    133132
    134         if (rc_orig != EOK) {
     133        if (rc_orig != EOK)
    135134                return (int) rc_orig;
    136         }
    137135               
    138         if (rc != EOK) {
     136        if (rc != EOK)
    139137                return (int) rc;
    140         }
    141138       
    142139        return (int) IPC_GET_ARG1(answer);
     
    147144        size_t size;
    148145        char *p = vfs_absolutize(path, &size);
    149         if (!p) {
     146        if (!p)
    150147                return ENOMEM;
    151         }
    152148        int root = vfs_root();
    153149        if (root < 0) {
     
    221217
    222218int vfs_mount(int mp, const char *fs_name, service_id_t serv, const char *opts,
    223 unsigned int flags, unsigned int instance, int *mountedfd)
     219    unsigned int flags, unsigned int instance, int *mountedfd)
    224220{
    225221        sysarg_t rc, rc1;
    226222       
    227         if (!mountedfd) {
     223        if (!mountedfd)
    228224                flags |= VFS_MOUNT_NO_REF;
    229         }
    230         if (mp < 0) {
     225        if (mp < 0)
    231226                flags |= VFS_MOUNT_CONNECT_ONLY;
    232         }
    233227       
    234228        ipc_call_t answer;
    235229        async_exch_t *exch = vfs_exchange_begin();
    236         aid_t req = async_send_4(exch, VFS_IN_MOUNT, mp, serv, flags, instance, &answer);
     230        aid_t req = async_send_4(exch, VFS_IN_MOUNT, mp, serv, flags, instance,
     231            &answer);
    237232
    238233        rc1 = async_data_write_start(exch, (void *) opts, str_size(opts));
    239234       
    240235        if (rc1 == EOK) {
    241                 rc1 = async_data_write_start(exch, (void *) fs_name, str_size(fs_name));
     236                rc1 = async_data_write_start(exch, (void *) fs_name,
     237                    str_size(fs_name));
    242238        }
    243239
     
    246242        async_wait_for(req, &rc);
    247243
    248         if (mountedfd) {
     244        if (mountedfd)
    249245                *mountedfd = (int) IPC_GET_ARG1(answer);
    250         }
    251        
    252         if (rc != EOK) {
     246       
     247        if (rc != EOK)
    253248                return rc;
    254         }
    255249        return rc1;
    256250}
     
    271265       
    272266        if (str_cmp(fqsn, "") == 0) {
    273                 /* No device specified, create a fresh
    274                    null/%d device instead */
     267                /*
     268                 * No device specified, create a fresh null/%d device instead.
     269                */
    275270                null_id = loc_null_create();
    276271               
     
    282277        }
    283278       
    284         if (flags & IPC_FLAG_BLOCKING) {
     279        if (flags & IPC_FLAG_BLOCKING)
    285280                flags = VFS_MOUNT_BLOCKING;
    286         } else {
     281        else
    287282                flags = 0;
    288         }
    289283       
    290284        service_id_t service_id;
     
    315309                if (root_fd >= 0) {
    316310                        fibril_mutex_unlock(&root_mutex);
    317                         if (null_id != -1) {
     311                        if (null_id != -1)
    318312                                loc_null_destroy(null_id);
    319                         }
    320313                        return EBUSY;
    321314                }
    322315               
    323316                int root;
    324                 rc = vfs_mount(-1, fs_name, service_id, opts, flags, instance, &root);
    325                 if (rc == EOK) {
     317                rc = vfs_mount(-1, fs_name, service_id, opts, flags, instance,
     318                    &root);
     319                if (rc == EOK)
    326320                        root_fd = root;
    327                 }
    328321        } else {
    329322                if (root_fd < 0) {
    330323                        fibril_mutex_unlock(&root_mutex);
    331                         if (null_id != -1) {
     324                        if (null_id != -1)
    332325                                loc_null_destroy(null_id);
    333                         }
    334326                        return EINVAL;
    335327                }
     
    337329                int mpfd = _vfs_walk(root_fd, mpa, WALK_DIRECTORY);
    338330                if (mpfd >= 0) {
    339                         rc = vfs_mount(mpfd, fs_name, service_id, opts, flags, instance, NULL);
     331                        rc = vfs_mount(mpfd, fs_name, service_id, opts, flags,
     332                            instance, NULL);
    340333                        close(mpfd);
    341334                } else {
     
    355348{
    356349        int mp = vfs_lookup(mpp, WALK_MOUNT_POINT | WALK_DIRECTORY);
    357         if (mp < 0) {
     350        if (mp < 0)
    358351                return mp;
    359         }
    360352       
    361353        int rc = vfs_unmount(mp);
     
    368360        int flags = 0;
    369361        if (oflags & O_CREAT) {
    370                 if (oflags & O_EXCL) {
     362                if (oflags & O_EXCL)
    371363                        flags |= WALK_MUST_CREATE;
    372                 } else {
     364                else
    373365                        flags |= WALK_MAY_CREATE;
    374                 }
    375366        }
    376367        return flags;
     
    403394       
    404395        int mode =
    405                 ((oflag & O_RDWR) ? MODE_READ|MODE_WRITE : 0) |
    406                 ((oflag & O_RDONLY) ? MODE_READ : 0) |
    407                 ((oflag & O_WRONLY) ? MODE_WRITE : 0) |
    408                 ((oflag & O_APPEND) ? MODE_APPEND : 0);
     396            ((oflag & O_RDWR) ? MODE_READ | MODE_WRITE : 0) |
     397            ((oflag & O_RDONLY) ? MODE_READ : 0) |
     398            ((oflag & O_WRONLY) ? MODE_WRITE : 0) |
     399            ((oflag & O_APPEND) ? MODE_APPEND : 0);
    409400       
    410401        int rc = _vfs_open(fd, mode);
     
    476467        vfs_exchange_end(exch);
    477468       
    478         if (rc == EOK) {
     469        if (rc == EOK)
    479470                async_wait_for(req, &rc);
    480         } else {
     471        else
    481472                async_forget(req);
    482         }
    483473       
    484474        if (rc != EOK)
     
    518508        vfs_exchange_end(exch);
    519509       
    520         if (rc == EOK) {
     510        if (rc == EOK)
    521511                async_wait_for(req, &rc);
    522         } else {
     512        else
    523513                async_forget(req);
    524         }
    525514
    526515        if (rc != EOK)
     
    850839        async_wait_for(req, &rc_orig);
    851840       
    852         if (rc_orig != EOK) {
     841        if (rc_orig != EOK)
    853842                return (int) rc_orig;
    854         }
    855843        return rc;
    856844}
     
    911899       
    912900        int rc = _vfs_unlink2(root, pa, -1, WALK_DIRECTORY);
    913 
    914901        if (rc != EOK) {
    915902                errno = rc;
     
    10371024        fibril_mutex_lock(&cwd_mutex);
    10381025       
    1039         if (cwd_fd >= 0) {
     1026        if (cwd_fd >= 0)
    10401027                close(cwd_fd);
    1041         }
    1042        
    1043         if (cwd_path) {
     1028       
     1029        if (cwd_path)
    10441030                free(cwd_path);
    1045         }
    10461031       
    10471032        cwd_fd = fd;
     
    12481233int vfs_pass_handle(async_exch_t *vfs_exch, int file, async_exch_t *exch)
    12491234{
    1250         return async_state_change_start(exch, VFS_PASS_HANDLE, (sysarg_t)file, 0, vfs_exch);
     1235        return async_state_change_start(exch, VFS_PASS_HANDLE, (sysarg_t) file,
     1236            0, vfs_exch);
    12511237}
    12521238
     
    12641250
    12651251        sysarg_t ret;
    1266         sysarg_t rc = async_req_1_1(vfs_exch, VFS_IN_WAIT_HANDLE, high_descriptor, &ret);
     1252        sysarg_t rc = async_req_1_1(vfs_exch, VFS_IN_WAIT_HANDLE,
     1253            high_descriptor, &ret);
    12671254
    12681255        async_exchange_end(vfs_exch);
    12691256
    1270         if (rc != EOK) {
     1257        if (rc != EOK)
    12711258                return rc;
    1272         }
    12731259        return ret;
    12741260}
     
    12771263{
    12781264        async_exch_t *vfs_exch = vfs_exchange_begin();
    1279         int rc = async_req_2_0(vfs_exch, VFS_IN_CLONE, (sysarg_t) file, (sysarg_t) high_descriptor);
     1265        int rc = async_req_2_0(vfs_exch, VFS_IN_CLONE, (sysarg_t) file,
     1266            (sysarg_t) high_descriptor);
    12801267        vfs_exchange_end(vfs_exch);
    12811268        return rc;
  • uspace/lib/fs/libfs.c

    rb7f69f2 r61042de  
    7979static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t,
    8080    ipc_call_t *);
    81 static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
     81static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_callid_t,
     82    ipc_call_t *);
    8283
    8384static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)
     
    157158        rc = vfs_out_ops->write(service_id, index, pos, &wbytes, &nsize);
    158159
    159         if (rc == EOK)
    160                 async_answer_3(rid, EOK, wbytes, LOWER32(nsize), UPPER32(nsize));
    161         else
     160        if (rc == EOK) {
     161                async_answer_3(rid, EOK, wbytes, LOWER32(nsize),
     162                    UPPER32(nsize));
     163        } else
    162164                async_answer_0(rid, rc);
    163165}
     
    198200                bool destroy = (libfs_ops->lnkcnt_get(node) == 0);
    199201                libfs_ops->node_put(node);
    200                 if (destroy) {
     202                if (destroy)
    201203                        rc = vfs_out_ops->destroy(service_id, index);
    202                 }
    203204        }
    204205        async_answer_0(rid, rc);
     
    239240        fs_node_t *node = NULL;
    240241        rc = libfs_ops->node_get(&node, service_id, index);
    241         if (rc != EOK) {
     242        if (rc != EOK)
    242243                async_answer_0(rid, rc);
    243         }
    244         if (node == NULL) {
     244        if (node == NULL)
    245245                async_answer_0(rid, EINVAL);
    246         }
    247246       
    248247        uint64_t size = libfs_ops->size_get(node);
     
    260259        fs_node_t *node = NULL;
    261260        rc = libfs_ops->node_get(&node, service_id, index);
    262         if (rc != EOK) {
     261        if (rc != EOK)
    263262                async_answer_0(rid, rc);
    264         }
    265         if (node == NULL) {
     263        if (node == NULL)
    266264                async_answer_0(rid, EINVAL);
    267         }
    268265       
    269266        bool children = false;
     
    271268        libfs_ops->node_put(node);
    272269       
    273         if (rc != EOK) {
     270        if (rc != EOK)
    274271                async_answer_0(rid, rc);
    275         }
    276272        async_answer_0(rid, children ? ENOTEMPTY : EOK);
    277273}
     
    445441}
    446442
    447 static int plb_get_component(char *dest, unsigned *sz, unsigned *ppos, unsigned last)
     443static int plb_get_component(char *dest, unsigned *sz, unsigned *ppos,
     444    unsigned last)
    448445{
    449446        unsigned pos = *ppos;
     
    456453
    457454        char c = plb_get_char(pos);
    458         if (c == '/') {
     455        if (c == '/')
    459456                pos++;
    460         }
    461457       
    462458        for (int i = 0; i <= NAME_MAX; i++) {
     
    480476        ipc_callid_t wcall;
    481477       
    482         if (!async_data_write_receive(&wcall, &size)) {
     478        if (!async_data_write_receive(&wcall, &size))
    483479                return ENOENT;
    484         }
    485480        if (size > NAME_MAX + 1) {
    486481                async_answer_0(wcall, ERANGE);
     
    492487/** Link a file at a path.
    493488 */
    494 void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, ipc_call_t *req)
     489void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
     490    ipc_call_t *req)
    495491{
    496492        service_id_t parent_sid = IPC_GET_ARG1(*req);
     
    658654                        int64_t size = ops->size_get(cur);
    659655                        int32_t lsize = LOWER32(size);
    660                         if (lsize != size) {
     656                        if (lsize != size)
    661657                                lsize = -1;
    662                         }
    663658                       
    664659                        async_answer_5(rid, fs_handle, service_id,
     
    680675       
    681676                if (!cur) {
    682                         rc = ops->create(&cur, service_id, lflag & (L_FILE|L_DIRECTORY));
     677                        rc = ops->create(&cur, service_id,
     678                            lflag & (L_FILE | L_DIRECTORY));
    683679                        if (rc != EOK) {
    684680                                async_answer_0(rid, rc);
     
    703699out1:
    704700        if (!cur) {
    705                 async_answer_5(rid, fs_handle, service_id,
    706                     ops->index_get(par), last_next, -1, true);
     701                async_answer_5(rid, fs_handle, service_id, ops->index_get(par),
     702                    last_next, -1, true);
    707703                goto out;
    708704        }
     
    718714        int64_t size = ops->size_get(cur);
    719715        int32_t lsize = LOWER32(size);
    720         if (lsize != size) {
     716        if (lsize != size)
    721717                lsize = -1;
    722         }
    723718       
    724719        async_answer_5(rid, fs_handle, service_id, ops->index_get(cur), last,
     
    726721       
    727722out:
    728         if (par) {
     723        if (par)
    729724                (void) ops->node_put(par);
    730         }
    731        
    732         if (cur) {
     725       
     726        if (cur)
    733727                (void) ops->node_put(cur);
    734         }
    735        
    736         if (tmp) {
     728       
     729        if (tmp)
    737730                (void) ops->node_put(tmp);
    738         }
    739731}
    740732
     
    857849        async_answer_4(rid, rc, LOWER32(size), UPPER32(size),
    858850            ops->lnkcnt_get(fn),
    859             (ops->is_file(fn) ? L_FILE : 0) | (ops->is_directory(fn) ? L_DIRECTORY : 0));
     851            (ops->is_file(fn) ? L_FILE : 0) |
     852            (ops->is_directory(fn) ? L_DIRECTORY : 0));
    860853       
    861854        (void) ops->node_put(fn);
  • uspace/srv/fs/fat/fat.h

    rb7f69f2 r61042de  
    4141#include <sys/types.h>
    4242#include <stdbool.h>
     43#include <macros.h>
    4344#include "../../vfs/vfs.h"
    4445
     
    4647#define dprintf(...)    printf(__VA_ARGS__)
    4748#endif
    48 
    49 #define min(a, b)       ((a) < (b) ? (a) : (b))
    5049
    5150/*
  • uspace/srv/fs/mfs/mfs.h

    rb7f69f2 r61042de  
    4545#include <assert.h>
    4646#include <stdbool.h>
     47#include <macros.h>
    4748#include "../../vfs/vfs.h"
    4849
     
    5051
    5152/* #define DEBUG_MODE */
    52 
    53 #define min(a, b)       ((a) < (b) ? (a) : (b))
    5453
    5554#ifdef DEBUG_MODE
  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    rb7f69f2 r61042de  
    5454#include <libfs.h>
    5555
    56 #define min(a, b)               ((a) < (b) ? (a) : (b))
    57 #define max(a, b)               ((a) > (b) ? (a) : (b))
    58 
    5956/** All root nodes have index 0. */
    6057#define TMPFS_SOME_ROOT         0
  • 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.