Changeset 61042de in mainline

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

Files:

• lib/c/generic/vfs/vfs.c (modified) (22 diffs)
• lib/fs/libfs.c (modified) (16 diffs)
• srv/fs/fat/fat.h (modified) (2 diffs)
• srv/fs/mfs/mfs.h (modified) (2 diffs)
• srv/fs/tmpfs/tmpfs_ops.c (modified) (1 diff)
• srv/vfs/vfs_lookup.c (modified) (13 diffs)
• srv/vfs/vfs_node.c (modified) (5 diffs)
• srv/vfs/vfs_ops.c (modified) (30 diffs)

uspace/lib/c/generic/vfs/vfs.c

@@ -73 +73 @@
         fibril_mutex_lock(&root_mutex); 
         int r;
-        if (root_fd < 0) {
+        if (root_fd < 0)
                 r = ENOENT;
-        } else {
+        else
                 r = vfs_clone(root_fd, true);
-        }
         fibril_mutex_unlock(&root_mutex);
         return r;
@@ -85 +84 @@
 {
         fibril_mutex_lock(&root_mutex);
-        if (root_fd >= 0) {
+        if (root_fd >= 0)
                 close(root_fd);
-        }
         root_fd = vfs_clone(nroot, true);
         fibril_mutex_unlock(&root_mutex);
@@ -101 +99 @@
         fibril_mutex_lock(&vfs_mutex);
         
-        while (vfs_sess == NULL)
+        while (vfs_sess == NULL) {
                 vfs_sess = service_connect_blocking(SERVICE_VFS, INTERFACE_VFS,
                     0);
+        }
         
         fibril_mutex_unlock(&vfs_mutex);
@@ -132 +131 @@
         async_wait_for(req, &rc_orig);
 
-        if (rc_orig != EOK) {
+        if (rc_orig != EOK)
                 return (int) rc_orig;
-        }
                 
-        if (rc != EOK) {
+        if (rc != EOK)
                 return (int) rc;
-        }
         
         return (int) IPC_GET_ARG1(answer);
@@ -147 +144 @@
         size_t size;
         char *p = vfs_absolutize(path, &size);
-        if (!p) {
+        if (!p)
                 return ENOMEM;
-        }
         int root = vfs_root();
         if (root < 0) {
@@ -221 +217 @@
 
 int vfs_mount(int mp, const char *fs_name, service_id_t serv, const char *opts,
-unsigned int flags, unsigned int instance, int *mountedfd)
+    unsigned int flags, unsigned int instance, int *mountedfd)
 {
         sysarg_t rc, rc1;
         
-        if (!mountedfd) {
+        if (!mountedfd)
                 flags |= VFS_MOUNT_NO_REF;
-        }
-        if (mp < 0) {
+        if (mp < 0)
                 flags |= VFS_MOUNT_CONNECT_ONLY;
-        }
         
         ipc_call_t answer;
         async_exch_t *exch = vfs_exchange_begin();
-        aid_t req = async_send_4(exch, VFS_IN_MOUNT, mp, serv, flags, instance, &answer);
+        aid_t req = async_send_4(exch, VFS_IN_MOUNT, mp, serv, flags, instance,
+            &answer);
 
         rc1 = async_data_write_start(exch, (void *) opts, str_size(opts));
         
         if (rc1 == EOK) {
-                rc1 = async_data_write_start(exch, (void *) fs_name, str_size(fs_name));
+                rc1 = async_data_write_start(exch, (void *) fs_name,
+                    str_size(fs_name));
         }
 
@@ -246 +242 @@
         async_wait_for(req, &rc);
 
-        if (mountedfd) {
+        if (mountedfd)
                 *mountedfd = (int) IPC_GET_ARG1(answer);
-        }
-        
-        if (rc != EOK) {
+        
+        if (rc != EOK)
                 return rc;
-        }
         return rc1;
 }
@@ -271 +265 @@
         
         if (str_cmp(fqsn, "") == 0) {
-                /* No device specified, create a fresh
-                   null/%d device instead */
+                /*
+                 * No device specified, create a fresh null/%d device instead.
+                */
                 null_id = loc_null_create();
                 
@@ -282 +277 @@
         }
         
-        if (flags & IPC_FLAG_BLOCKING) {
+        if (flags & IPC_FLAG_BLOCKING)
                 flags = VFS_MOUNT_BLOCKING;
-        } else {
+        else
                 flags = 0;
-        }
         
         service_id_t service_id;
@@ -315 +309 @@
                 if (root_fd >= 0) {
                         fibril_mutex_unlock(&root_mutex);
-                        if (null_id != -1) {
+                        if (null_id != -1)
                                 loc_null_destroy(null_id);
-                        }
                         return EBUSY;
                 }
                 
                 int root;
-                rc = vfs_mount(-1, fs_name, service_id, opts, flags, instance, &root);
-                if (rc == EOK) {
+                rc = vfs_mount(-1, fs_name, service_id, opts, flags, instance,
+                    &root);
+                if (rc == EOK)
                         root_fd = root;
-                }
         } else {
                 if (root_fd < 0) {
                         fibril_mutex_unlock(&root_mutex);
-                        if (null_id != -1) {
+                        if (null_id != -1)
                                 loc_null_destroy(null_id);
-                        }
                         return EINVAL;
                 }
@@ -337 +329 @@
                 int mpfd = _vfs_walk(root_fd, mpa, WALK_DIRECTORY);
                 if (mpfd >= 0) {
-                        rc = vfs_mount(mpfd, fs_name, service_id, opts, flags, instance, NULL);
+                        rc = vfs_mount(mpfd, fs_name, service_id, opts, flags,
+                            instance, NULL);
                         close(mpfd);
                 } else {
@@ -355 +348 @@
 {
         int mp = vfs_lookup(mpp, WALK_MOUNT_POINT | WALK_DIRECTORY);
-        if (mp < 0) {
+        if (mp < 0)
                 return mp;
-        }
         
         int rc = vfs_unmount(mp);
@@ -368 +360 @@
         int flags = 0;
         if (oflags & O_CREAT) {
-                if (oflags & O_EXCL) {
+                if (oflags & O_EXCL)
                         flags |= WALK_MUST_CREATE;
-                } else {
+                else
                         flags |= WALK_MAY_CREATE;
-                }
         }
         return flags;
@@ -403 +394 @@
         
         int mode =
-                ((oflag & O_RDWR) ? MODE_READ|MODE_WRITE : 0) |
-                ((oflag & O_RDONLY) ? MODE_READ : 0) |
-                ((oflag & O_WRONLY) ? MODE_WRITE : 0) |
-                ((oflag & O_APPEND) ? MODE_APPEND : 0);
+            ((oflag & O_RDWR) ? MODE_READ | MODE_WRITE : 0) |
+            ((oflag & O_RDONLY) ? MODE_READ : 0) |
+            ((oflag & O_WRONLY) ? MODE_WRITE : 0) |
+            ((oflag & O_APPEND) ? MODE_APPEND : 0);
         
         int rc = _vfs_open(fd, mode); 
@@ -476 +467 @@
         vfs_exchange_end(exch);
         
-        if (rc == EOK) {
+        if (rc == EOK)
                 async_wait_for(req, &rc);
-        } else {
+        else
                 async_forget(req);
-        }
         
         if (rc != EOK)
@@ -518 +508 @@
         vfs_exchange_end(exch);
         
-        if (rc == EOK) {
+        if (rc == EOK)
                 async_wait_for(req, &rc);
-        } else {
+        else
                 async_forget(req);
-        }
 
         if (rc != EOK)
@@ -850 +839 @@
         async_wait_for(req, &rc_orig);
         
-        if (rc_orig != EOK) {
+        if (rc_orig != EOK)
                 return (int) rc_orig;
-        }
         return rc;
 }
@@ -911 +899 @@
         
         int rc = _vfs_unlink2(root, pa, -1, WALK_DIRECTORY);
-
         if (rc != EOK) {
                 errno = rc;
@@ -1037 +1024 @@
         fibril_mutex_lock(&cwd_mutex);
         
-        if (cwd_fd >= 0) {
+        if (cwd_fd >= 0)
                 close(cwd_fd);
-        }
-        
-        if (cwd_path) {
+        
+        if (cwd_path)
                 free(cwd_path);
-        }
         
         cwd_fd = fd;
@@ -1248 +1233 @@
 int vfs_pass_handle(async_exch_t *vfs_exch, int file, async_exch_t *exch)
 {
-        return async_state_change_start(exch, VFS_PASS_HANDLE, (sysarg_t)file, 0, vfs_exch);
+        return async_state_change_start(exch, VFS_PASS_HANDLE, (sysarg_t) file,
+            0, vfs_exch);
 }
 
@@ -1264 +1250 @@
 
         sysarg_t ret;
-        sysarg_t rc = async_req_1_1(vfs_exch, VFS_IN_WAIT_HANDLE, high_descriptor, &ret);
+        sysarg_t rc = async_req_1_1(vfs_exch, VFS_IN_WAIT_HANDLE,
+            high_descriptor, &ret);
 
         async_exchange_end(vfs_exch);
 
-        if (rc != EOK) {
+        if (rc != EOK)
                 return rc;
-        }
         return ret;
 }
@@ -1277 +1263 @@
 {
         async_exch_t *vfs_exch = vfs_exchange_begin();
-        int rc = async_req_2_0(vfs_exch, VFS_IN_CLONE, (sysarg_t) file, (sysarg_t) high_descriptor);
+        int rc = async_req_2_0(vfs_exch, VFS_IN_CLONE, (sysarg_t) file,
+            (sysarg_t) high_descriptor);
         vfs_exchange_end(vfs_exch);
         return rc;

uspace/lib/fs/libfs.c

@@ -79 +79 @@
 static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t,
     ipc_call_t *);
-static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
+static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_callid_t,
+    ipc_call_t *);
 
 static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)
@@ -157 +158 @@
         rc = vfs_out_ops->write(service_id, index, pos, &wbytes, &nsize);
 
-        if (rc == EOK)
-                async_answer_3(rid, EOK, wbytes, LOWER32(nsize), UPPER32(nsize));
-        else
+        if (rc == EOK) {
+                async_answer_3(rid, EOK, wbytes, LOWER32(nsize),
+                    UPPER32(nsize));
+        } else
                 async_answer_0(rid, rc);
 }
@@ -198 +200 @@
                 bool destroy = (libfs_ops->lnkcnt_get(node) == 0);
                 libfs_ops->node_put(node);
-                if (destroy) {
+                if (destroy)
                         rc = vfs_out_ops->destroy(service_id, index);
-                }
         }
         async_answer_0(rid, rc);
@@ -239 +240 @@
         fs_node_t *node = NULL;
         rc = libfs_ops->node_get(&node, service_id, index);
-        if (rc != EOK) {
+        if (rc != EOK)
                 async_answer_0(rid, rc);
-        }
-        if (node == NULL) {
+        if (node == NULL)
                 async_answer_0(rid, EINVAL);
-        }
         
         uint64_t size = libfs_ops->size_get(node);
@@ -260 +259 @@
         fs_node_t *node = NULL;
         rc = libfs_ops->node_get(&node, service_id, index);
-        if (rc != EOK) {
+        if (rc != EOK)
                 async_answer_0(rid, rc);
-        }
-        if (node == NULL) {
+        if (node == NULL)
                 async_answer_0(rid, EINVAL);
-        }
         
         bool children = false;
@@ -271 +268 @@
         libfs_ops->node_put(node);
         
-        if (rc != EOK) {
+        if (rc != EOK)
                 async_answer_0(rid, rc);
-        }
         async_answer_0(rid, children ? ENOTEMPTY : EOK);
 }
@@ -445 +441 @@
 }
 
-static int plb_get_component(char *dest, unsigned *sz, unsigned *ppos, unsigned last)
+static int plb_get_component(char *dest, unsigned *sz, unsigned *ppos,
+    unsigned last)
 {
         unsigned pos = *ppos;
@@ -456 +453 @@
 
         char c = plb_get_char(pos); 
-        if (c == '/') {
+        if (c == '/')
                 pos++;
-        }
         
         for (int i = 0; i <= NAME_MAX; i++) {
@@ -480 +476 @@
         ipc_callid_t wcall;
         
-        if (!async_data_write_receive(&wcall, &size)) {
+        if (!async_data_write_receive(&wcall, &size))
                 return ENOENT;
-        }
         if (size > NAME_MAX + 1) {
                 async_answer_0(wcall, ERANGE);
@@ -492 +487 @@
 /** Link a file at a path.
  */
-void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, ipc_call_t *req)
+void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
+    ipc_call_t *req)
 {
         service_id_t parent_sid = IPC_GET_ARG1(*req);
@@ -658 +654 @@
                         int64_t size = ops->size_get(cur);
                         int32_t lsize = LOWER32(size);
-                        if (lsize != size) {
+                        if (lsize != size)
                                 lsize = -1;
-                        }
                         
                         async_answer_5(rid, fs_handle, service_id,
@@ -680 +675 @@
         
                 if (!cur) {
-                        rc = ops->create(&cur, service_id, lflag & (L_FILE|L_DIRECTORY));
+                        rc = ops->create(&cur, service_id,
+                            lflag & (L_FILE | L_DIRECTORY));
                         if (rc != EOK) {
                                 async_answer_0(rid, rc);
@@ -703 +699 @@
 out1:
         if (!cur) {
-                async_answer_5(rid, fs_handle, service_id,
-                    ops->index_get(par), last_next, -1, true);
+                async_answer_5(rid, fs_handle, service_id, ops->index_get(par),
+                    last_next, -1, true);
                 goto out;
         }
@@ -718 +714 @@
         int64_t size = ops->size_get(cur);
         int32_t lsize = LOWER32(size);
-        if (lsize != size) {
+        if (lsize != size)
                 lsize = -1;
-        }
         
         async_answer_5(rid, fs_handle, service_id, ops->index_get(cur), last,
@@ -726 +721 @@
         
 out:
-        if (par) {
+        if (par)
                 (void) ops->node_put(par);
-        }
-        
-        if (cur) {
+        
+        if (cur)
                 (void) ops->node_put(cur);
-        }
-        
-        if (tmp) {
+        
+        if (tmp)
                 (void) ops->node_put(tmp);
-        }
 }
 
@@ -857 +849 @@
         async_answer_4(rid, rc, LOWER32(size), UPPER32(size),
             ops->lnkcnt_get(fn),
-            (ops->is_file(fn) ? L_FILE : 0) | (ops->is_directory(fn) ? L_DIRECTORY : 0));
+            (ops->is_file(fn) ? L_FILE : 0) |
+            (ops->is_directory(fn) ? L_DIRECTORY : 0));
         
         (void) ops->node_put(fn);

uspace/srv/fs/fat/fat.h

@@ -41 +41 @@
 #include <sys/types.h>
 #include <stdbool.h>
+#include <macros.h>
 #include "../../vfs/vfs.h"
 
@@ -46 +47 @@
 #define dprintf(...)    printf(__VA_ARGS__)
 #endif
-
-#define min(a, b)       ((a) < (b) ? (a) : (b))
 
 /*

uspace/srv/fs/mfs/mfs.h

@@ -45 +45 @@
 #include <assert.h>
 #include <stdbool.h>
+#include <macros.h>
 #include "../../vfs/vfs.h"
 
@@ -50 +51 @@
 
 /* #define DEBUG_MODE */
-
-#define min(a, b)       ((a) < (b) ? (a) : (b))
 
 #ifdef DEBUG_MODE

uspace/srv/fs/tmpfs/tmpfs_ops.c

@@ -54 +54 @@
 #include <libfs.h>
 
-#define min(a, b)               ((a) < (b) ? (a) : (b))
-#define max(a, b)               ((a) > (b) ? (a) : (b))
-
 /** All root nodes have index 0. */
 #define TMPFS_SOME_ROOT         0

uspace/srv/vfs/vfs_lookup.c

@@ -49 +49 @@
 #include <assert.h>
 
-#define DPRINTF(...)
-
-#define min(a, b)  ((a) < (b) ? (a) : (b))
-
 FIBRIL_MUTEX_INITIALIZE(plb_mutex);
 LIST_INITIALIZE(plb_entries);   /**< PLB entry ring buffer. */
 uint8_t *plb = NULL;
 
-static int plb_insert_entry(plb_entry_t *entry, char *path, size_t *start, size_t len)
+static int plb_insert_entry(plb_entry_t *entry, char *path, size_t *start,
+    size_t len)
 {
         fibril_mutex_lock(&plb_mutex);
@@ -174 +171 @@
                 
                 rc = vfs_lookup_internal(base, path, L_DIRECTORY, &res);
-                if (rc != EOK) {
+                if (rc != EOK)
                         goto out;
-                }
                 triplet = &res.triplet;
                 
@@ -190 +186 @@
         }
         
-        if (triplet->fs_handle != child->fs_handle || triplet->service_id != child->service_id) {
+        if (triplet->fs_handle != child->fs_handle ||
+            triplet->service_id != child->service_id) {
                 rc = EXDEV;
                 goto out;
@@ -196 +193 @@
         
         async_exch_t *exch = vfs_exchange_grab(triplet->fs_handle);
-        aid_t req = async_send_3(exch, VFS_OUT_LINK, triplet->service_id, triplet->index, child->index, NULL);
+        aid_t req = async_send_3(exch, VFS_OUT_LINK, triplet->service_id,
+            triplet->index, child->index, NULL);
         
         rc = async_data_write_start(exch, component, str_size(component) + 1);
@@ -202 +200 @@
         async_wait_for(req, &orig_rc);
         vfs_exchange_release(exch);
-        if (orig_rc != EOK) {
+        if (orig_rc != EOK)
                 rc = orig_rc;
-        }
         
 out:
-        DPRINTF("vfs_link_internal() with path '%s' returns %d\n", path, rc);
         return rc;
 }
 
 static int out_lookup(vfs_triplet_t *base, size_t *pfirst, size_t *plen,
-        int lflag, vfs_lookup_res_t *result)
+    int lflag, vfs_lookup_res_t *result)
 {
         assert(base);
@@ -220 +216 @@
         ipc_call_t answer;
         async_exch_t *exch = vfs_exchange_grab(base->fs_handle);
-        aid_t req = async_send_5(exch, VFS_OUT_LOOKUP, (sysarg_t) *pfirst, (sysarg_t) *plen,
-            (sysarg_t) base->service_id, (sysarg_t) base->index, (sysarg_t) lflag, &answer);
+        aid_t req = async_send_5(exch, VFS_OUT_LOOKUP, (sysarg_t) *pfirst,
+            (sysarg_t) *plen, (sysarg_t) base->service_id,
+            (sysarg_t) base->index, (sysarg_t) lflag, &answer);
         async_wait_for(req, &rc);
         vfs_exchange_release(exch);
         
-        if ((int) rc < 0) {
+        if ((int) rc < 0)
                 return (int) rc;
-        }
         
         unsigned last = *pfirst + *plen;
@@ -237 +233 @@
         result->triplet.index = (fs_index_t) IPC_GET_ARG2(answer);
         result->size = (int64_t)(int32_t) IPC_GET_ARG4(answer);
-        result->type = IPC_GET_ARG5(answer) ? VFS_NODE_DIRECTORY : VFS_NODE_FILE;
+        result->type = IPC_GET_ARG5(answer) ?
+            VFS_NODE_DIRECTORY : VFS_NODE_FILE;
         return EOK;
 }
@@ -253 +250 @@
  *
  */
-int vfs_lookup_internal(vfs_node_t *base, char *path, int lflag, vfs_lookup_res_t *result)
+int vfs_lookup_internal(vfs_node_t *base, char *path, int lflag,
+    vfs_lookup_res_t *result)
 {
         assert(base != NULL);
@@ -262 +260 @@
         char *npath = canonify(path, &len);
         if (!npath) {
-                DPRINTF("vfs_lookup_internal() can't canonify path: %s\n", path);
                 rc = EINVAL;
                 return rc;
@@ -274 +271 @@
         plb_entry_t entry;
         rc = plb_insert_entry(&entry, path, &first, len);
-        if (rc != EOK) {
-                DPRINTF("vfs_lookup_internal() can't insert entry into PLB: %d\n", rc);
+        if (rc != EOK)
                 return rc;
-        }
         
         size_t next = first;
@@ -286 +281 @@
         /* Resolve path as long as there are mount points to cross. */
         while (nlen > 0) {
-                while (base->mount != NULL) {
+                while (base->mount) {
                         if (lflag & L_DISABLE_MOUNTS) {
                                 rc = EXDEV;
@@ -295 +290 @@
                 }
                 
-                rc = out_lookup((vfs_triplet_t *) base, &next, &nlen, lflag, &res);
-                if (rc != EOK) {
+                rc = out_lookup((vfs_triplet_t *) base, &next, &nlen, lflag,
+                    &res);
+                if (rc != EOK)
                         goto out;
-                }
                 
                 if (nlen > 0) {
@@ -349 +344 @@
 out:
         plb_clear_entry(&entry, first, len);
-        DPRINTF("vfs_lookup_internal() with path '%s' returns %d\n", path, rc);
         return rc;
 }

uspace/srv/vfs/vfs_node.c

@@ -113 +113 @@
         node->refcnt--;
         if (node->refcnt == 0) {
-                
                 /*
                  * We are dropping the last reference to this node.
@@ -127 +126 @@
         if (free_node) {
                 /*
-                 * DESTROY will free up the file's resources if there are no more hard links.
+                 * VFS_OUT_DESTROY will free up the file's resources if there
+                 * are no more hard links.
                  */
                 
                 async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
-                async_msg_2(exch, VFS_OUT_DESTROY,
-                        (sysarg_t) node->service_id, (sysarg_t)node->index);
+                async_msg_2(exch, VFS_OUT_DESTROY, (sysarg_t) node->service_id,
+                    (sysarg_t)node->index);
                 vfs_exchange_release(exch);
 
@@ -300 +300 @@
         vfs_triplet_t *tri = key;
         vfs_node_t *node = hash_table_get_inst(item, vfs_node_t, nh_link);
-        return node->fs_handle == tri->fs_handle 
-                && node->service_id == tri->service_id
-                && node->index == tri->index;
+        return node->fs_handle == tri->fs_handle &&
+            node->service_id == tri->service_id && node->index == tri->index;
 }
 
@@ -323 +322 @@
                 
                 async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
-                (void) async_req_2_2(exch, VFS_OUT_GET_SIZE,
-                        node->service_id, node->index, &sz1, &sz2);
+                (void) async_req_2_2(exch, VFS_OUT_GET_SIZE, node->service_id,
+                    node->index, &sz1, &sz2);
                 vfs_exchange_release(exch);
                 
@@ -335 +334 @@
 {
         async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
-        int rc = async_req_2_0(exch, VFS_OUT_IS_EMPTY, node->service_id, node->index);
+        int rc = async_req_2_0(exch, VFS_OUT_IS_EMPTY, node->service_id,
+            node->index);
         vfs_exchange_release(exch);
         return rc == ENOTEMPTY;

uspace/srv/vfs/vfs_ops.c

@@ -67 +67 @@
         size_t res = 0;
         
-        while (a[res] == b[res] && a[res] != 0) {
+        while (a[res] == b[res] && a[res] != 0)
                 res++;
-        }
-        
-        if (a[res] == b[res]) {
+        
+        if (a[res] == b[res])
                 return res;
-        }
         
         res--;
-        while (a[res] != '/') {
+        while (a[res] != '/')
                 res--;
-        }
         return res;
 }
@@ -86 +83 @@
 {
         async_exch_t *exch = vfs_exchange_grab(file->fs_handle);
-        async_msg_2(exch, VFS_OUT_DESTROY,
-                (sysarg_t) file->service_id, (sysarg_t) file->index);
+        async_msg_2(exch, VFS_OUT_DESTROY, (sysarg_t) file->service_id,
+            (sysarg_t) file->index);
         vfs_exchange_release(exch);
 }
@@ -95 +92 @@
         /* Lookup the file structure corresponding to fd. */
         vfs_file_t *oldfile = vfs_file_get(oldfd);
-        if (oldfile == NULL) {
-                return EBADF;
-        }
+        if (oldfile == NULL)
+                return EBADF;
+
         assert(oldfile->node != NULL);
         
@@ -122 +119 @@
 {
         /* If the file descriptors are the same, do nothing. */
-        if (oldfd == newfd) {
+        if (oldfd == newfd)
                 return EOK;
-        }
         
         /* Lookup the file structure corresponding to oldfd. */
         vfs_file_t *oldfile = vfs_file_get(oldfd);
-        if (!oldfile) {
-                return EBADF;
-        }
+        if (!oldfile)
+                return EBADF;
         
         /* Make sure newfd is closed. */
@@ -145 +140 @@
 {
         vfs_file_t *file = vfs_file_get(fd);
-        if (!file) {
-                return EBADF;
-        }
+        if (!file)
+                return EBADF;
+
         assert(file->node);
         
@@ -182 +177 @@
         
         fibril_mutex_lock(&fs_list_lock);
-        while (1) {
+        while (true) {
                 fs_handle = fs_name_to_handle(instance, fsname, false);
                 
-                if (fs_handle != 0 || !(flags & VFS_MOUNT_BLOCKING)) {
+                if (fs_handle != 0 || !(flags & VFS_MOUNT_BLOCKING))
                         break;
-                }
                 
                 fibril_condvar_wait(&fs_list_cv, &fs_list_lock);
@@ -193 +187 @@
         fibril_mutex_unlock(&fs_list_lock);
 
-        if (fs_handle == 0) {
+        if (fs_handle == 0)
                 return ENOENT;
-        }
         
         /* Tell the mountee that it is being mounted. */
@@ -212 +205 @@
         vfs_exchange_release(exch);
         
-        if (rc != EOK) {
+        if (rc != EOK)
                 return rc;
-        }
         
         vfs_lookup_res_t res;
@@ -284 +276 @@
         fibril_rwlock_write_unlock(&namespace_rwlock);
         
-        if (rc != EOK) {
+        if (rc != EOK)
                 goto out;
-        }
         
         if (flags & VFS_MOUNT_NO_REF) {
@@ -300 +291 @@
         
 out:
-        if (mp) {
+        if (mp)
                 vfs_file_put(mp);
-        }
-        if (file) {
-                vfs_file_put(file);
-        }
+        if (file)
+                vfs_file_put(file);
+
         if (rc != EOK && fd >= 0) {
                 vfs_fd_free(fd);
@@ -317 +307 @@
 int vfs_op_open2(int fd, int flags)
 {
-        if (flags == 0) {
+        if (flags == 0)
                 return EINVAL;
-        }
 
         vfs_file_t *file = vfs_file_get(fd);
-        if (!file) {
-                return EBADF;
-        }
+        if (!file)
+                return EBADF;
         
         if ((flags & ~file->permissions) != 0) {
@@ -454 +442 @@
          * write implementation does not modify the file size.
          */
-        if (rlock) {
+        if (rlock)
                 fibril_rwlock_read_lock(&file->node->contents_rwlock);
-        } else {
+        else
                 fibril_rwlock_write_lock(&file->node->contents_rwlock);
-        }
         
         if (file->node->type == VFS_NODE_DIRECTORY) {
@@ -496 +483 @@
         size_t bytes = IPC_GET_ARG1(answer);
         
-        if (file->node->type == VFS_NODE_DIRECTORY) {
+        if (file->node->type == VFS_NODE_DIRECTORY)
                 fibril_rwlock_read_unlock(&namespace_rwlock);
-        }
         
         /* Unlock the VFS node. */
@@ -513 +499 @@
         
         /* Update the position pointer and unlock the open file. */
-        if (rc == EOK) {
+        if (rc == EOK)
                 file->pos += bytes;
-        }
         vfs_file_put(file);     
 
@@ -534 +519 @@
 {
         vfs_file_t *base_file = vfs_file_get(basefd);
-        if (!base_file) {
-                return EBADF;
-        }
+        if (!base_file)
+                return EBADF;
+
         vfs_node_t *base = base_file->node;
         vfs_node_addref(base);
@@ -577 +562 @@
         }
 
-        rc = vfs_lookup_internal(base, old, L_DISABLE_MOUNTS,
-            &old_lr);
+        rc = vfs_lookup_internal(base, old, L_DISABLE_MOUNTS, &old_lr);
         if (rc != EOK) {
                 vfs_node_put(base);
@@ -598 +582 @@
         if (rc != EOK) {
                 vfs_link_internal(base, old, &old_lr.triplet);
-                if (orig_unlinked) {
+                if (orig_unlinked)
                         vfs_link_internal(base, new, &new_lr_orig.triplet);
-                }
                 vfs_node_put(base);
                 fibril_rwlock_write_unlock(&namespace_rwlock);
@@ -609 +592 @@
             &old_lr);
         if (rc != EOK) {
-                if (orig_unlinked) {
+                if (orig_unlinked)
                         vfs_link_internal(base, new, &new_lr_orig.triplet);
-                }
                 vfs_node_put(base);
                 fibril_rwlock_write_unlock(&namespace_rwlock);
@@ -634 +616 @@
 {
         vfs_file_t *file = vfs_file_get(fd);
-        if (!file) {
-                return EBADF;
-        }
+        if (!file)
+                return EBADF;
         
         switch (whence) {
@@ -724 +705 @@
 {
         vfs_file_t *file = vfs_file_get(fd);
-        if (!file) {
-                return EBADF;
-        }
+        if (!file)
+                return EBADF;
         
         async_exch_t *fs_exch = vfs_exchange_grab(file->node->fs_handle);
@@ -733 +713 @@
         ipc_call_t answer;
         msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->service_id,
-                file->node->index, &answer);
+            file->node->index, &answer);
         
         vfs_exchange_release(fs_exch);
@@ -760 +740 @@
 {
         vfs_file_t *file = vfs_file_get(fd);
-        if (!file) {
-                return EBADF;
-        }
+        if (!file)
+                return EBADF;
 
         fibril_rwlock_write_lock(&file->node->contents_rwlock);
         
         int rc = vfs_truncate_internal(file->node->fs_handle,
-                file->node->service_id, file->node->index, size);
-        if (rc == EOK) {
+            file->node->service_id, file->node->index, size);
+        if (rc == EOK)
                 file->node->size = size;
-        }
         
         fibril_rwlock_write_unlock(&file->node->contents_rwlock);
@@ -783 +761 @@
         vfs_file_t *expect = NULL;
         
-        if (parentfd == expectfd) {
+        if (parentfd == expectfd)
                 return EINVAL;
-        }
         
         fibril_rwlock_write_lock(&namespace_rwlock);
         
-        int lflag = (wflag&WALK_DIRECTORY) ? L_DIRECTORY: 0;
+        int lflag = (wflag & WALK_DIRECTORY) ? L_DIRECTORY: 0;
 
         /* 
@@ -824 +801 @@
                 vfs_lookup_res_t lr;
                 rc = vfs_lookup_internal(parent->node, path, lflag, &lr);
-                if (rc != EOK) {
+                if (rc != EOK)
                         goto exit;
-                }
                 
                 vfs_node_t *found_node = vfs_node_peek(&lr);
@@ -841 +817 @@
         vfs_lookup_res_t lr;
         rc = vfs_lookup_internal(parent->node, path, lflag | L_UNLINK, &lr);
-        if (rc != EOK) {
+        if (rc != EOK)
                 goto exit;
-        }
 
         /* If the node is not held by anyone, try to destroy it. */
@@ -853 +828 @@
 
 exit:
-        if (path) {
+        if (path)
                 free(path);
-        }
-        if (parent) {
+        if (parent)
                 vfs_file_put(parent);
-        }
-        if (expect) {
+        if (expect)
                 vfs_file_put(expect);
-        }
         fibril_rwlock_write_unlock(&namespace_rwlock);
         return rc;
@@ -869 +841 @@
 {
         vfs_file_t *mp = vfs_file_get(mpfd);
-        if (mp == NULL) {
-                return EBADF;
-        }
+        if (mp == NULL)
+                return EBADF;
         
         if (mp->node->mount == NULL) {
@@ -922 +893 @@
 static inline bool walk_flags_valid(int flags)
 {
-        if ((flags & ~WALK_ALL_FLAGS) != 0) {
+        if ((flags & ~WALK_ALL_FLAGS) != 0)
                 return false;
-        }
-        if ((flags & WALK_MAY_CREATE) && (flags & WALK_MUST_CREATE)) {
+        if ((flags & WALK_MAY_CREATE) && (flags & WALK_MUST_CREATE))
                 return false;
-        }
-        if ((flags & WALK_REGULAR) && (flags & WALK_DIRECTORY)) {
+        if ((flags & WALK_REGULAR) && (flags & WALK_DIRECTORY))
                 return false;
-        }
         if ((flags & WALK_MAY_CREATE) || (flags & WALK_MUST_CREATE)) {
-                if (!(flags & WALK_DIRECTORY) && !(flags & WALK_REGULAR)) {
+                if (!(flags & WALK_DIRECTORY) && !(flags & WALK_REGULAR))
                         return false;
-                }
         }
         return true;
@@ -942 +909 @@
 {
         int lflags = 0;
-        if ((flags & WALK_MAY_CREATE) || (flags & WALK_MUST_CREATE)) {
+        if ((flags & WALK_MAY_CREATE) || (flags & WALK_MUST_CREATE))
                 lflags |= L_CREATE;
-        }
-        if (flags & WALK_MUST_CREATE) {
+        if (flags & WALK_MUST_CREATE)
                 lflags |= L_EXCLUSIVE;
-        }
-        if (flags & WALK_REGULAR) {
+        if (flags & WALK_REGULAR)
                 lflags |= L_FILE;
-        }
-        if (flags & WALK_DIRECTORY) {
+        if (flags & WALK_DIRECTORY)
                 lflags |= L_DIRECTORY;
-        }
-        if (flags & WALK_MOUNT_POINT) {
+        if (flags & WALK_MOUNT_POINT)
                 lflags |= L_MP;
-        }
         return lflags;
 }
@@ -962 +924 @@
 int vfs_op_walk(int parentfd, int flags, char *path, int *out_fd)
 {
-        if (!walk_flags_valid(flags)) {
+        if (!walk_flags_valid(flags))
                 return EINVAL;
-        }
         
         vfs_file_t *parent = vfs_file_get(parentfd);
-        if (!parent) {
-                return EBADF;
-        }
+        if (!parent)
+                return EBADF;
         
         fibril_rwlock_read_lock(&namespace_rwlock);