Change formatting rules

kernel/proc/procgroup.c

@@ -20,40 +20,40 @@ static spin_lock_t procgroup_tree_lock = SPIN_LOCK_INIT;
 
 static struct id_alloc pgid_alloc;
 
-void procgroup_pgid_alloc_init (void) { id_alloc_init (&pgid_alloc, PGIDS_MAX); }
+void procgroup_pgid_alloc_init(void) { id_alloc_init(&pgid_alloc, PGIDS_MAX); }
 
-struct procgroup* procgroup_find (int pgid) {
+struct procgroup* procgroup_find(int pgid) {
   uint64_t fpgt;
 
   struct procgroup* procgroup = NULL;
 
-  spin_lock (&procgroup_tree_lock, &fpgt);
-  rbtree_find (struct procgroup, &procgroup_tree, pgid, procgroup, procgroup_tree_link, pgid);
-  spin_unlock (&procgroup_tree_lock, fpgt);
+  spin_lock(&procgroup_tree_lock, &fpgt);
+  rbtree_find(struct procgroup, &procgroup_tree, pgid, procgroup, procgroup_tree_link, pgid);
+  spin_unlock(&procgroup_tree_lock, fpgt);
 
   return procgroup;
 }
 
-uintptr_t procgroup_map (struct procgroup* procgroup, uintptr_t vaddr, size_t pages, uint32_t flags,
-                         uintptr_t* out_paddr) {
+uintptr_t procgroup_map(struct procgroup* procgroup, uintptr_t vaddr, size_t pages, uint32_t flags,
+                        uintptr_t* out_paddr) {
   uint64_t fpg;
 
-  spin_lock (&procgroup->lock, &fpg);
+  spin_lock(&procgroup->lock, &fpg);
 
   vaddr = (vaddr == 0) ? procgroup->map_base : vaddr;
 
-  struct proc_mapping* mapping = malloc (sizeof (*mapping));
+  struct proc_mapping* mapping = malloc(sizeof(*mapping));
 
   if (mapping == NULL) {
-    spin_unlock (&procgroup->lock, fpg);
+    spin_unlock(&procgroup->lock, fpg);
     return 0;
   }
 
-  uintptr_t paddr = pmm_alloc (pages);
+  uintptr_t paddr = pmm_alloc(pages);
 
   if (paddr == PMM_ALLOC_ERR) {
-    free (mapping);
-    spin_unlock (&procgroup->lock, fpg);
+    free(mapping);
+    spin_unlock(&procgroup->lock, fpg);
     return 0;
   }
 
@@ -66,19 +66,19 @@ uintptr_t procgroup_map (struct procgroup* procgroup, uintptr_t vaddr, size_t pa
 
   procgroup->map_base += pages * PAGE_SIZE;
 
-  list_append (procgroup->mappings, &mapping->proc_mappings_link);
+  list_append(procgroup->mappings, &mapping->proc_mappings_link);
 
   for (uintptr_t vpage = vaddr, ppage = paddr; vpage < vaddr + pages * PAGE_SIZE;
        vpage += PAGE_SIZE, ppage += PAGE_SIZE) {
-    mm_map_page (&procgroup->pd, ppage, vpage, flags);
+    mm_map_page(&procgroup->pd, ppage, vpage, flags);
   }
 
-  spin_unlock (&procgroup->lock, fpg);
+  spin_unlock(&procgroup->lock, fpg);
 
   return vaddr;
 }
 
-bool procgroup_unmap (struct procgroup* procgroup, uintptr_t start_vaddr, size_t pages) {
+bool procgroup_unmap(struct procgroup* procgroup, uintptr_t start_vaddr, size_t pages) {
   uint64_t fpg;
   size_t unmap_size = pages * PAGE_SIZE;
   uintptr_t end_vaddr = start_vaddr + unmap_size;
@@ -87,15 +87,15 @@ bool procgroup_unmap (struct procgroup* procgroup, uintptr_t start_vaddr, size_t
 
   bool used_tail_mapping = false;
 
-  struct proc_mapping* tail_mapping = malloc (sizeof (*tail_mapping));
+  struct proc_mapping* tail_mapping = malloc(sizeof(*tail_mapping));
   if (tail_mapping == NULL)
     return false;
 
-  spin_lock (&procgroup->lock, &fpg);
+  spin_lock(&procgroup->lock, &fpg);
 
-  list_foreach (procgroup->mappings, mapping_link, mapping_link_tmp) {
+  list_foreach(procgroup->mappings, mapping_link, mapping_link_tmp) {
     struct proc_mapping* mapping =
-        list_entry (mapping_link, struct proc_mapping, proc_mappings_link);
+        list_entry(mapping_link, struct proc_mapping, proc_mappings_link);
 
     uintptr_t m_start = mapping->vaddr;
     uintptr_t m_end = mapping->vaddr + mapping->size;
@@ -107,7 +107,7 @@ bool procgroup_unmap (struct procgroup* procgroup, uintptr_t start_vaddr, size_t
       size_t free_size = free_vend - free_vstart;
 
       uintptr_t ppage_to_free = mapping->paddr + (free_vstart - m_start);
-      pmm_free (ppage_to_free, free_size / PAGE_SIZE);
+      pmm_free(ppage_to_free, free_size / PAGE_SIZE);
 
       /* split in the middle */
       if ((start_vaddr > m_start) && (end_vaddr < m_end)) {
@@ -117,8 +117,8 @@ bool procgroup_unmap (struct procgroup* procgroup, uintptr_t start_vaddr, size_t
 
         mapping->size = start_vaddr - m_start;
 
-        list_insert_after (procgroup->mappings, &mapping->proc_mappings_link,
-                           &tail_mapping->proc_mappings_link);
+        list_insert_after(procgroup->mappings, &mapping->proc_mappings_link,
+                          &tail_mapping->proc_mappings_link);
 
         used_tail_mapping = true;
 
@@ -131,152 +131,151 @@ bool procgroup_unmap (struct procgroup* procgroup, uintptr_t start_vaddr, size_t
       } else if ((start_vaddr > m_start) && (end_vaddr >= m_end)) { /* shrink right */
         mapping->size = start_vaddr - m_start;
       } else { /* full overlap */
-        list_remove (procgroup->mappings, &mapping->proc_mappings_link);
-        free (mapping);
+        list_remove(procgroup->mappings, &mapping->proc_mappings_link);
+        free(mapping);
       }
     }
   }
 
   if (!used_tail_mapping)
-    free (tail_mapping);
+    free(tail_mapping);
 
   for (uintptr_t vpage = start_vaddr; vpage < end_vaddr; vpage += PAGE_SIZE) {
-    mm_unmap_page (&procgroup->pd, vpage);
+    mm_unmap_page(&procgroup->pd, vpage);
   }
 
-  spin_unlock (&procgroup->lock, fpg);
+  spin_unlock(&procgroup->lock, fpg);
 
   return true;
 }
 
-struct procgroup* procgroup_create (void) {
+struct procgroup* procgroup_create(void) {
   uint64_t fpgt;
 
-  struct procgroup* procgroup = malloc (sizeof (*procgroup));
+  struct procgroup* procgroup = malloc(sizeof(*procgroup));
   if (procgroup == NULL) {
     return NULL;
   }
 
-  memset (procgroup, 0, sizeof (*procgroup));
+  memset(procgroup, 0, sizeof(*procgroup));
 
-  if (!id_alloc_init (&procgroup->rid_alloc, PROCGROUP_RESOURCES_MAX)) {
-    free (procgroup);
+  if (!id_alloc_init(&procgroup->rid_alloc, PROCGROUP_RESOURCES_MAX)) {
+    free(procgroup);
     return NULL;
   }
 
-  procgroup->pgid = id_alloc (&pgid_alloc);
+  procgroup->pgid = id_alloc(&pgid_alloc);
 
   if (procgroup->pgid < 0) {
-    id_alloc_fini (&procgroup->rid_alloc);
-    free (procgroup);
+    id_alloc_fini(&procgroup->rid_alloc);
+    free(procgroup);
     return NULL;
   }
 
   procgroup->memb_proc_tree = NULL;
   procgroup->lock = SPIN_LOCK_INIT;
-  procgroup->pd.cr3_paddr = mm_alloc_user_pd_phys ();
+  procgroup->pd.cr3_paddr = mm_alloc_user_pd_phys();
   procgroup->map_base = PROC_MAP_BASE;
 
-  if (proc_create_resource_mail (procgroup) == NULL) {
-    id_alloc_fini (&procgroup->rid_alloc);
-    free (procgroup);
+  if (proc_create_resource_mail(procgroup) == NULL) {
+    id_alloc_fini(&procgroup->rid_alloc);
+    free(procgroup);
     return NULL;
   }
 
-  if (proc_create_resource_stream (procgroup) == NULL) {
-    id_alloc_fini (&procgroup->rid_alloc);
-    free (procgroup);
+  if (proc_create_resource_stream(procgroup) == NULL) {
+    id_alloc_fini(&procgroup->rid_alloc);
+    free(procgroup);
     return NULL;
   }
 
-  if (proc_create_resource_stream (procgroup) == NULL) {
-    id_alloc_fini (&procgroup->rid_alloc);
-    free (procgroup);
+  if (proc_create_resource_stream(procgroup) == NULL) {
+    id_alloc_fini(&procgroup->rid_alloc);
+    free(procgroup);
     return NULL;
   }
 
-  spin_lock (&procgroup_tree_lock, &fpgt);
-  rbtree_insert (struct procgroup, &procgroup_tree, &procgroup->procgroup_tree_link,
-                 procgroup_tree_link, pgid);
-  spin_unlock (&procgroup_tree_lock, fpgt);
+  spin_lock(&procgroup_tree_lock, &fpgt);
+  rbtree_insert(struct procgroup, &procgroup_tree, &procgroup->procgroup_tree_link,
+                procgroup_tree_link, pgid);
+  spin_unlock(&procgroup_tree_lock, fpgt);
 
   return procgroup;
 }
 
-void procgroup_attach (struct procgroup* procgroup, struct proc* proc) {
+void procgroup_attach(struct procgroup* procgroup, struct proc* proc) {
   uint64_t fpg, fp;
 
-  spin_lock (&procgroup->lock, &fpg);
-  spin_lock (&proc->lock, &fp);
+  spin_lock(&procgroup->lock, &fpg);
+  spin_lock(&proc->lock, &fp);
 
-  rbtree_insert (struct proc, &procgroup->memb_proc_tree, &proc->procgroup_memb_tree_link,
-                 procgroup_memb_tree_link, pid);
+  rbtree_insert(struct proc, &procgroup->memb_proc_tree, &proc->procgroup_memb_tree_link,
+                procgroup_memb_tree_link, pid);
 
-  spin_unlock (&proc->lock, fp);
-  spin_unlock (&procgroup->lock, fpg);
+  spin_unlock(&proc->lock, fp);
+  spin_unlock(&procgroup->lock, fpg);
 }
 
-static void procgroup_delete (struct procgroup* procgroup, struct reschedule_ctx* rctx) {
+static void procgroup_delete(struct procgroup* procgroup, struct reschedule_ctx* rctx) {
   uint64_t fpg, fpgt;
 
-  spin_lock (&procgroup_tree_lock, &fpgt);
-  spin_lock (&procgroup->lock, &fpg);
+  spin_lock(&procgroup_tree_lock, &fpgt);
+  spin_lock(&procgroup->lock, &fpg);
 
-  rbtree_delete (&procgroup_tree, &procgroup->procgroup_tree_link);
+  rbtree_delete(&procgroup_tree, &procgroup->procgroup_tree_link);
 
-  spin_unlock (&procgroup->lock, fpg);
-  spin_unlock (&procgroup_tree_lock, fpgt);
+  spin_unlock(&procgroup->lock, fpg);
+  spin_unlock(&procgroup_tree_lock, fpgt);
 
   /* delete resources */
   struct rb_node_link* rnode;
-  rbtree_first (&procgroup->resource_tree, rnode);
+  rbtree_first(&procgroup->resource_tree, rnode);
   while (rnode) {
     struct rb_node_link* next;
-    rbtree_next (rnode, next);
+    rbtree_next(rnode, next);
 
-    struct proc_resource* resource = rbtree_entry (rnode, struct proc_resource, resource_tree_link);
+    struct proc_resource* resource = rbtree_entry(rnode, struct proc_resource, resource_tree_link);
 
     rnode = next;
 
-    proc_delete_resource (procgroup, resource, rctx);
+    proc_delete_resource(procgroup, resource, rctx);
   }
 
   /* delete mappings */
   struct list_node_link *mapping_link, *mapping_link_tmp;
-  list_foreach (procgroup->mappings, mapping_link, mapping_link_tmp) {
+  list_foreach(procgroup->mappings, mapping_link, mapping_link_tmp) {
     struct proc_mapping* mapping =
-        list_entry (mapping_link, struct proc_mapping, proc_mappings_link);
+        list_entry(mapping_link, struct proc_mapping, proc_mappings_link);
 
-    pmm_free (mapping->paddr, mapping->size / PAGE_SIZE);
-    free (mapping);
+    pmm_free(mapping->paddr, mapping->size / PAGE_SIZE);
+    free(mapping);
   }
 
-  proc_env_cleanup (procgroup);
+  proc_env_cleanup(procgroup);
 
-  pmm_free (procgroup->pd.cr3_paddr, 1);
+  pmm_free(procgroup->pd.cr3_paddr, 1);
 
-  free (procgroup->tls.tls_tmpl);
+  free(procgroup->tls.tls_tmpl);
 
-  id_alloc_fini (&procgroup->rid_alloc);
-  id_free (&pgid_alloc, procgroup->pgid);
+  id_alloc_fini(&procgroup->rid_alloc);
+  id_free(&pgid_alloc, procgroup->pgid);
 
-  free (procgroup);
+  free(procgroup);
 }
 
-void procgroup_detach (struct procgroup* procgroup, struct proc* proc,
-                       struct reschedule_ctx* rctx) {
+void procgroup_detach(struct procgroup* procgroup, struct proc* proc, struct reschedule_ctx* rctx) {
   uint64_t fpg, fp;
 
-  spin_lock (&procgroup->lock, &fpg);
-  spin_lock (&proc->lock, &fp);
+  spin_lock(&procgroup->lock, &fpg);
+  spin_lock(&proc->lock, &fp);
 
-  rbtree_delete (&procgroup->memb_proc_tree, &proc->procgroup_memb_tree_link);
+  rbtree_delete(&procgroup->memb_proc_tree, &proc->procgroup_memb_tree_link);
   struct rb_node_link* memb_tree = procgroup->memb_proc_tree;
 
-  spin_unlock (&proc->lock, fp);
-  spin_unlock (&procgroup->lock, fpg);
+  spin_unlock(&proc->lock, fp);
+  spin_unlock(&procgroup->lock, fpg);
 
   if (memb_tree == NULL) {
-    procgroup_delete (procgroup, rctx);
+    procgroup_delete(procgroup, rctx);
   }
 }