Changeset 61042de in mainline for uspace/lib


Ignore:
Timestamp:
2017-03-18T20:58:08Z (9 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/lib
Files:
2 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);
Note: See TracChangeset for help on using the changeset viewer.