Changeset 61042de in mainline for uspace/lib/c/generic/vfs/vfs.c


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