New clang-format options

6 files changed, 133 insertions, 66 deletions

diff --git a/kernel/fs/devfs.c b/kernel/fs/devfs.c
index c0ad7ce..2705dc8 100644
--- a/kernel/fs/devfs.c
+++ b/kernel/fs/devfs.c
@@ -29,9 +29,11 @@ vfs_inode_t *devfs_add_file(
 }
 
 vfs_inode_t *devfs_open(const char *file) {
-  for (int i = 0; i < num_files; i++)
-    if (isequal_n(files[i].name, file, strlen(files[i].name)))
+  for (int i = 0; i < num_files; i++) {
+    if (isequal_n(files[i].name, file, strlen(files[i].name))) {
       return files[i].inode;
+    }
+  }
 
   return 0;
 }
@@ -53,8 +55,9 @@ int stdout_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   (void)fd;
 
   int rc = len;
-  for (; len--;)
+  for (; len--;) {
     putc(*buffer++);
+  }
   return rc;
 }
 
@@ -63,8 +66,9 @@ int serial_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   (void)fd;
 
   int rc = len;
-  for (; len--;)
+  for (; len--;) {
     write_serial(*buffer++);
+  }
   return rc;
 }
 
diff --git a/kernel/fs/ext2.c b/kernel/fs/ext2.c
index 60800a9..ccf2fdf 100644
--- a/kernel/fs/ext2.c
+++ b/kernel/fs/ext2.c
@@ -112,16 +112,18 @@ u32 num_block_groups(void) {
   u32 num_blocks = superblock->num_blocks;
   u32 num_blocks_in_group = superblock->num_blocks_in_group;
   u32 b = num_blocks / num_blocks_in_group;
-  if (num_blocks % num_blocks_in_group != 0)
+  if (num_blocks % num_blocks_in_group != 0) {
     b++;
+  }
 
   // Rounding up the total number of inodes divided by the number of
   // inodes per block group
   u32 num_inodes = superblock->num_inodes;
   u32 num_inodes_in_group = superblock->num_inodes_in_group;
   u32 i = num_inodes / num_inodes_in_group;
-  if (num_inodes % num_inodes_in_group != 0)
+  if (num_inodes % num_inodes_in_group != 0) {
     i++;
+  }
   // Both (and check them against each other)
   assert(i == b);
   return i;
@@ -164,8 +166,9 @@ void ext2_get_inode_header(int inode_index, inode_t *data) {
 }
 
 void ext2_write_inode(int inode_index, inode_t *data) {
-  if (ext2_last_inode_read == inode_index)
+  if (ext2_last_inode_read == inode_index) {
     ext2_last_inode_read = -1; // Invalidate the cache
+  }
   u32 block_index;
   u32 block_offset;
   ext2_block_containing_inode(inode_index, &block_index, &block_offset);
@@ -194,16 +197,20 @@ int ext2_get_inode_in_directory(int dir_inode, char *file,
   for (; data_p <= (data_end - sizeof(direntry_header_t)) &&
          (dir = (direntry_header_t *)data_p)->inode;
        data_p += dir->size) {
-    if (0 == dir->size)
+    if (0 == dir->size) {
       break;
-    if (0 == dir->name_length)
+    }
+    if (0 == dir->name_length) {
       continue;
+    }
     if (0 ==
         memcmp(data_p + sizeof(direntry_header_t), file, dir->name_length)) {
-      if (strlen(file) > dir->name_length)
+      if (strlen(file) > dir->name_length) {
         continue;
-      if (entry)
+      }
+      if (entry) {
         memcpy(entry, data_p, sizeof(direntry_header_t));
+      }
       return dir->inode;
     }
   }
@@ -225,12 +232,15 @@ int ext2_read_dir(int dir_inode, u8 *buffer, size_t len, size_t offset) {
   for (; data_p <= (data_end - sizeof(direntry_header_t)) &&
          (dir = (direntry_header_t *)data_p)->inode && len > 0;
        data_p += dir->size, n_dir++) {
-    if (0 == dir->size)
+    if (0 == dir->size) {
       break;
-    if (0 == dir->name_length)
+    }
+    if (0 == dir->name_length) {
       continue;
-    if (n_dir < (offset / sizeof(struct dirent)))
+    }
+    if (n_dir < (offset / sizeof(struct dirent))) {
       continue;
+    }
 
     memcpy(tmp_entry.d_name, data_p + sizeof(direntry_header_t),
            dir->name_length);
@@ -250,8 +260,9 @@ int ext2_read_dir(int dir_inode, u8 *buffer, size_t len, size_t offset) {
 u32 ext2_find_inode(const char *file) {
   int cur_path_inode = EXT2_ROOT_INODE;
 
-  if (*file == '/' && *(file + 1) == '\0')
+  if (*file == '/' && *(file + 1) == '\0') {
     return cur_path_inode;
+  }
 
   char *str = copy_and_allocate_string(file);
   char *orig_str = str;
@@ -264,8 +275,9 @@ u32 ext2_find_inode(const char *file) {
 
     for (; '/' != *str && '\0' != *str; str++)
       ;
-    if ('\0' == *str)
+    if ('\0' == *str) {
       final = 1;
+    }
 
     *str = '\0';
 
@@ -276,8 +288,9 @@ u32 ext2_find_inode(const char *file) {
       return 0;
     }
 
-    if (final)
+    if (final) {
       break;
+    }
 
     // The expected returned entry is a directory
     if (TYPE_INDICATOR_DIRECTORY != a.type_indicator) {
@@ -298,8 +311,9 @@ u32 get_singly_block_index(u32 singly_block_ptr, u32 i) {
 }
 
 int get_block(inode_t *inode, u32 i) {
-  if (i < 12)
+  if (i < 12) {
     return inode->block_pointers[i];
+  }
 
   i -= 12;
   u32 singly_block_size = block_byte_size / (32 / 8);
@@ -356,8 +370,9 @@ int get_free_inode(int allocate) {
   for (u32 g = 0; g < num_block_groups(); g++) {
     get_group_descriptor(g, &block_group);
 
-    if (0 == block_group.num_unallocated_inodes_in_group)
+    if (0 == block_group.num_unallocated_inodes_in_group) {
       continue;
+    }
 
     u8 bitmap[BLOCK_SIZE];
     ext2_read_block(block_group.inode_usage_bitmap, bitmap, BLOCK_SIZE, 0);
@@ -388,22 +403,25 @@ int write_inode(int inode_num, u8 *data, u64 size, u64 offset, u64 *file_size,
   inode_t *inode = (inode_t *)inode_buffer;
 
   u64 fsize = (u64)(((u64)inode->_upper_32size << 32) | (u64)inode->low_32size);
-  if (append)
+  if (append) {
     offset = fsize;
+  }
 
   u32 block_start = offset / block_byte_size;
   u32 block_offset = offset % block_byte_size;
 
   int num_blocks_used = inode->num_disk_sectors / (BLOCK_SIZE / SECTOR_SIZE);
 
-  if (size + offset > fsize)
+  if (size + offset > fsize) {
     fsize = size + offset;
+  }
 
   int num_blocks_required = BLOCKS_REQUIRED(fsize, BLOCK_SIZE);
 
   for (int i = num_blocks_used; i < num_blocks_required; i++) {
-    if (i > 12)
+    if (i > 12) {
       assert(0);
+    }
     int b = get_free_block(1 /*true*/);
     assert(-1 != b);
     inode->block_pointers[i] = b;
@@ -442,17 +460,21 @@ int read_inode(int inode_num, u8 *data, u64 size, u64 offset, u64 *file_size) {
 
   u64 fsize = (u64)(((u64)inode->_upper_32size << 32) | (u64)inode->low_32size);
 
-  if (file_size)
+  if (file_size) {
     *file_size = fsize;
+  }
 
-  if (size > fsize - offset)
+  if (size > fsize - offset) {
     size -= ((size + offset) - fsize);
+  }
 
-  if (size == 0)
+  if (size == 0) {
     return 0;
+  }
 
-  if (offset > fsize)
+  if (offset > fsize) {
     return 0;
+  }
 
   u32 block_start = offset / block_byte_size;
   u32 block_offset = offset % block_byte_size;
@@ -558,8 +580,9 @@ int ext2_truncate(vfs_fd_t *fd, size_t length) {
 
 vfs_inode_t *ext2_open(const char *path) {
   u32 inode_num = ext2_find_inode(path);
-  if (0 == inode_num)
+  if (0 == inode_num) {
     return NULL;
+  }
 
   u8 buffer[inode_size];
   inode_t *ext2_inode = (inode_t *)buffer;
@@ -601,10 +624,12 @@ u64 end_of_last_entry_position(int dir_inode, u64 *entry_offset,
   for (; pos < file_size && (dir = (direntry_header_t *)data_p)->size;
        data_p += dir->size, prev = pos, pos += dir->size)
     ;
-  if (entry_offset)
+  if (entry_offset) {
     *entry_offset = prev;
-  if (meta)
+  }
+  if (meta) {
     memcpy(meta, ((u8 *)data) + prev, sizeof(direntry_header_t));
+  }
   kfree(data);
   return pos;
 }
@@ -633,8 +658,9 @@ void ext2_create_entry(int directory_inode, direntry_header_t entry_header,
   entry_header.size += (4 - (entry_header.size % 4));
 
   u32 length_till_next_block = 1024 - (new_entry_offset % 1024);
-  if (0 == length_till_next_block)
+  if (0 == length_till_next_block) {
     length_till_next_block = 1024;
+  }
   assert(entry_header.size < length_till_next_block);
   entry_header.size = length_till_next_block;
 
@@ -659,8 +685,9 @@ int ext2_find_parent(char *path, u32 *parent_inode, char **filename) {
     return 1;
   } else {
     int r = ext2_find_inode(path);
-    if (0 == r)
+    if (0 == r) {
       return 0;
+    }
     *parent_inode = r;
     return 1;
   }
@@ -799,8 +826,9 @@ void parse_superblock(void) {
       ; // TODO: Fail properly
   }
 
-  if (1 <= superblock->major_version)
+  if (1 <= superblock->major_version) {
     inode_size = ((ext_superblock_t *)superblock)->inode_size;
+  }
 
   inodes_per_block = block_byte_size / inode_size;
 }
diff --git a/kernel/fs/fifo.c b/kernel/fs/fifo.c
index 4ae7c8a..9844b9e 100644
--- a/kernel/fs/fifo.c
+++ b/kernel/fs/fifo.c
@@ -28,12 +28,14 @@ int fifo_object_read(u8 *buffer, u64 offset, u64 len, FIFO_FILE *file) {
     return -EAGAIN;
   }
 
-  if (len == 0)
+  if (len == 0) {
     return 0;
+  }
 
   file->can_write = 1;
-  if (len > file->write_len)
+  if (len > file->write_len) {
     len = file->write_len;
+  }
 
   memcpy(buffer, file->buffer, len);
   // Shift bufffer to the left
diff --git a/kernel/fs/shm.c b/kernel/fs/shm.c
index 5eb7f23..e0c0211 100644
--- a/kernel/fs/shm.c
+++ b/kernel/fs/shm.c
@@ -16,11 +16,13 @@ void shm_init(void) {
 int shm_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   vfs_vm_object_t *p = fd->inode->internal_object;
 
-  if (offset > p->size)
+  if (offset > p->size) {
     return -EFBIG;
+  }
 
-  if (offset + len > p->size)
+  if (offset + len > p->size) {
     len = p->size - offset;
+  }
 
   memcpy((void *)((uintptr_t)((uintptr_t)p->virtual_object + offset)), buffer,
          len);
@@ -30,11 +32,13 @@ int shm_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
 int shm_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   vfs_vm_object_t *p = fd->inode->internal_object;
 
-  if (offset > p->size)
+  if (offset > p->size) {
     return -EFBIG;
+  }
 
-  if (offset + len > p->size)
+  if (offset + len > p->size) {
     len = p->size - offset;
+  }
 
   memcpy((void *)buffer,
          (void *)((uintptr_t)((uintptr_t)p->virtual_object + offset)), len);
@@ -54,10 +58,11 @@ int shm_ftruncate(vfs_fd_t *fd, size_t length) {
   p->virtual_object = ksbrk(length);
   int n = (uintptr_t)align_page((void *)(u32)length) / 0x1000;
   p->object = kmalloc(sizeof(void *) * n);
-  for (int i = 0; i < n; i++)
+  for (int i = 0; i < n; i++) {
     p->object[i] =
         (void *)(get_page(p->virtual_object + (i * 0x1000), NULL, 0, 0)->frame *
                  0x1000);
+  }
   return 0;
 }
 
diff --git a/kernel/fs/tmpfs.c b/kernel/fs/tmpfs.c
index b9f7b7e..1054a27 100644
--- a/kernel/fs/tmpfs.c
+++ b/kernel/fs/tmpfs.c
@@ -14,8 +14,9 @@ void tmp_close(vfs_fd_t *fd) {
 int tmp_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   tmp_inode *calling_file = fd->inode->internal_object;
   tmp_inode *child_file = calling_file->read_inode->internal_object;
-  if (child_file->is_closed)
+  if (child_file->is_closed) {
     return -EPIPE;
+  }
 
   int rc = fifo_object_write(buffer, offset, len, child_file->fifo);
   calling_file->read_inode->has_data = child_file->fifo->has_data;
@@ -26,8 +27,9 @@ int tmp_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
 int tmp_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   tmp_inode *calling_file = fd->inode->internal_object;
   tmp_inode *child_file = calling_file->read_inode->internal_object;
-  if (calling_file->is_closed)
+  if (calling_file->is_closed) {
     return -EPIPE;
+  }
 
   int rc = fifo_object_read(buffer, offset, len, calling_file->fifo);
   fd->inode->has_data = calling_file->fifo->has_data;
diff --git a/kernel/fs/vfs.c b/kernel/fs/vfs.c
index 214cfd3..2a072e9 100644
--- a/kernel/fs/vfs.c
+++ b/kernel/fs/vfs.c
@@ -58,11 +58,14 @@ int vfs_create_fd(int flags, int mode, int is_tty, vfs_inode_t *inode,
                   vfs_fd_t **fd) {
   process_t *p = (process_t *)get_current_task();
   int i;
-  for (i = 0; i < 100; i++)
-    if (!p->file_descriptors[i])
+  for (i = 0; i < 100; i++) {
+    if (!p->file_descriptors[i]) {
       break;
-  if (p->file_descriptors[i])
+    }
+  }
+  if (p->file_descriptors[i]) {
     return -1;
+  }
   vfs_fd_t *r = kmalloc(sizeof(vfs_fd_t));
   r->flags = flags;
   r->mode = mode;
@@ -71,8 +74,9 @@ int vfs_create_fd(int flags, int mode, int is_tty, vfs_inode_t *inode,
   r->is_tty = is_tty;
   r->offset = 0;
   p->file_descriptors[i] = r;
-  if (fd)
+  if (fd) {
     *fd = r;
+  }
   return i;
 }
 
@@ -81,16 +85,18 @@ int vfs_create_file(const char *file) {
   int length = 0;
   for (int i = 0; i < num_mounts; i++) {
     int path_len = strlen(mounts[i].path);
-    if (path_len <= length)
+    if (path_len <= length) {
       continue;
+    }
 
     if (isequal_n(mounts[i].path, file, path_len)) {
       length = path_len;
       file_mount = &mounts[i];
     }
   }
-  if (1 != length)
+  if (1 != length) {
     file += length;
+  }
 
   if (!file_mount) {
     kprintf("vfs_internal_open could not find mounted path for file : %s\n",
@@ -106,16 +112,18 @@ vfs_inode_t *vfs_internal_open(const char *file) {
   int length = 0;
   for (int i = 0; i < num_mounts; i++) {
     int path_len = strlen(mounts[i].path);
-    if (path_len <= length)
+    if (path_len <= length) {
       continue;
+    }
 
     if (isequal_n(mounts[i].path, file, path_len)) {
       length = path_len;
       file_mount = &mounts[i];
     }
   }
-  if (1 != length)
+  if (1 != length) {
     file += length;
+  }
 
   if (!file_mount) {
     kprintf("vfs_internal_open could not find mounted path for file : %s\n",
@@ -130,8 +138,9 @@ vfs_inode_t *vfs_internal_open(const char *file) {
 // Does canonicalization of absolute paths
 int vfs_clean_path(const char *path, char *result) {
   // It has to be a absolute path
-  if ('/' != *path)
+  if ('/' != *path) {
     return 0;
+  }
   const char *result_start = result;
   int start_directory = 0;
   int should_insert_slash = 0;
@@ -149,8 +158,9 @@ int vfs_clean_path(const char *path, char *result) {
           // "/../foo". A "/.." should become a "/"
           // Therefore it skips going back to the parent
           if (*path == '/') {
-            if (result_start == result)
+            if (result_start == result) {
               return 0;
+            }
             result--;
           }
         } else {
@@ -165,8 +175,9 @@ int vfs_clean_path(const char *path, char *result) {
       }
     }
     start_directory = ('/' == *path);
-    if ('\0' == *path)
+    if ('\0' == *path) {
       break;
+    }
     *result = *path;
     result++;
   }
@@ -196,8 +207,9 @@ char *vfs_resolve_path(const char *file, char *resolved_path) {
 
 int vfs_fstat(int fd, struct stat *buf) {
   vfs_fd_t *fd_ptr = get_vfs_fd(fd);
-  if (!fd_ptr)
+  if (!fd_ptr) {
     return -EBADF;
+  }
   assert(fd_ptr->inode->stat);
   return fd_ptr->inode->stat(fd_ptr, buf);
 }
@@ -207,8 +219,9 @@ int vfs_chdir(const char *path) {
   char *resolved_path = vfs_resolve_path(path, tmp_path);
   {
     int tmp_fd = vfs_open(resolved_path, O_READ, 0);
-    if (0 > tmp_fd)
+    if (0 > tmp_fd) {
       return tmp_fd;
+    }
     struct stat stat_result;
     vfs_fstat(tmp_fd, &stat_result);
     if (STAT_DIR != stat_result.st_mode) {
@@ -218,8 +231,10 @@ int vfs_chdir(const char *path) {
     vfs_close(tmp_fd);
   }
   strcpy(get_current_task()->current_working_directory, resolved_path);
-  if ('/' != resolved_path[strlen(resolved_path)] && strlen(resolved_path) != 1)
+  if ('/' != resolved_path[strlen(resolved_path)] &&
+      strlen(resolved_path) != 1) {
     strcat(get_current_task()->current_working_directory, "/");
+  }
   return 0;
 }
 
@@ -228,16 +243,18 @@ int vfs_mkdir(const char *path, int mode) {
   int length = 0;
   for (int i = 0; i < num_mounts; i++) {
     int path_len = strlen(mounts[i].path);
-    if (path_len <= length)
+    if (path_len <= length) {
       continue;
+    }
 
     if (isequal_n(mounts[i].path, path, path_len)) {
       length = path_len;
       file_mount = &mounts[i];
     }
   }
-  if (1 != length)
+  if (1 != length) {
     path += length;
+  }
 
   if (!file_mount) {
     kprintf("vfs_internal_open could not find mounted path for file : %s\n",
@@ -283,8 +300,9 @@ int vfs_close(int fd) {
   get_current_task()->file_descriptors[fd] = 0;
   // If no references left then free the contents
   if (0 == fd_ptr->reference_count) {
-    if (fd_ptr->inode->close)
+    if (fd_ptr->inode->close) {
       fd_ptr->inode->close(fd_ptr);
+    }
 
     kfree(fd_ptr);
   }
@@ -292,8 +310,9 @@ int vfs_close(int fd) {
 }
 
 int raw_vfs_pread(vfs_fd_t *vfs_fd, void *buf, u64 count, u64 offset) {
-  if (!(vfs_fd->flags & O_READ))
+  if (!(vfs_fd->flags & O_READ)) {
     return -EBADF;
+  }
   return vfs_fd->inode->read(buf, offset, count, vfs_fd);
 }
 
@@ -308,8 +327,9 @@ int vfs_pread(int fd, void *buf, u64 count, u64 offset) {
     return -EBADF;
   }
   vfs_fd_t *vfs_fd = get_current_task()->file_descriptors[fd];
-  if (!vfs_fd)
+  if (!vfs_fd) {
     return -EBADF;
+  }
   int rc = raw_vfs_pread(vfs_fd, buf, count, offset);
   if (-EAGAIN == rc && count > 0) {
     if (!(vfs_fd->flags & O_NONBLOCK)) {
@@ -333,8 +353,9 @@ int raw_vfs_pwrite(vfs_fd_t *vfs_fd, void *buf, u64 count, u64 offset) {
 
 int vfs_pwrite(int fd, void *buf, u64 count, u64 offset) {
   vfs_fd_t *vfs_fd = get_vfs_fd(fd);
-  if (!vfs_fd)
+  if (!vfs_fd) {
     return -EBADF;
+  }
   if (!(vfs_fd->flags & O_WRITE)) {
     return -EBADF;
   }
@@ -343,8 +364,9 @@ int vfs_pwrite(int fd, void *buf, u64 count, u64 offset) {
 
 vfs_vm_object_t *vfs_get_vm_object(int fd, u64 length, u64 offset) {
   vfs_fd_t *vfs_fd = get_vfs_fd(fd);
-  if (!vfs_fd)
+  if (!vfs_fd) {
     return NULL;
+  }
   vfs_vm_object_t *r = vfs_fd->inode->get_vm_object(length, offset, vfs_fd);
   return r;
 }
@@ -358,15 +380,19 @@ int vfs_dup2(int org_fd, int new_fd) {
 
 int vfs_ftruncate(int fd, size_t length) {
   vfs_fd_t *fd_ptr = get_vfs_fd(fd);
-  if (!fd_ptr)
+  if (!fd_ptr) {
     return -EBADF;
-  if (!(fd_ptr->flags & O_READ))
+  }
+  if (!(fd_ptr->flags & O_READ)) {
     return -EINVAL;
+  }
   vfs_inode_t *inode = fd_ptr->inode;
-  if (!inode)
+  if (!inode) {
     return -EINVAL;
-  if (!inode->truncate)
+  }
+  if (!inode->truncate) {
     return -EINVAL;
+  }
 
   return inode->truncate(fd_ptr, length);
 }