Changes in kernel/generic/src/mm/as.c [63e27ef:560b81c] in mainline

File:

• kernel/generic/src/mm/as.c (modified) (24 diffs)

kernel/generic/src/mm/as.c

@@ -67 +67 @@
 #include <arch/asm.h>
 #include <panic.h>
-#include <assert.h>
+#include <debug.h>
 #include <print.h>
-#include <mem.h>
+#include <memstr.h>
 #include <macros.h>
 #include <bitops.h>
@@ -189 +189 @@
         DEADLOCK_PROBE_INIT(p_asidlock);
         
-        assert(as != AS);
-        assert(atomic_get(&as->refcount) == 0);
+        ASSERT(as != AS);
+        ASSERT(atomic_get(&as->refcount) == 0);
         
         /*
@@ -236 +236 @@
         bool cond = true;
         while (cond) {
-                assert(!list_empty(&as->as_area_btree.leaf_list));
+                ASSERT(!list_empty(&as->as_area_btree.leaf_list));
                 
                 btree_node_t *node =
@@ -298 +298 @@
     size_t count, bool guarded, as_area_t *avoid)
 {
-        assert((addr % PAGE_SIZE) == 0);
-        assert(mutex_locked(&as->lock));
+        ASSERT((addr % PAGE_SIZE) == 0);
+        ASSERT(mutex_locked(&as->lock));
 
         /*
@@ -455 +455 @@
     size_t size, bool guarded)
 {
-        assert(mutex_locked(&as->lock));
+        ASSERT(mutex_locked(&as->lock));
         
         if (size == 0)
@@ -532 +532 @@
         
         mutex_lock(&sh_info->lock);
-        assert(sh_info->refcount);
+        ASSERT(sh_info->refcount);
         
         if (--sh_info->refcount == 0) {
@@ -696 +696 @@
 NO_TRACE static as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
 {
-        assert(mutex_locked(&as->lock));
+        ASSERT(mutex_locked(&as->lock));
         
         btree_node_t *leaf;
@@ -827 +827 @@
                 bool cond = true;
                 while (cond) {
-                        assert(!list_empty(&area->used_space.leaf_list));
+                        ASSERT(!list_empty(&area->used_space.leaf_list));
                         
                         btree_node_t *node =
@@ -893 +893 @@
                                             ptr + P2SZ(i), false, &pte);
                                         
-                                        assert(found);
-                                        assert(PTE_VALID(&pte));
-                                        assert(PTE_PRESENT(&pte));
+                                        ASSERT(found);
+                                        ASSERT(PTE_VALID(&pte));
+                                        ASSERT(PTE_PRESENT(&pte));
                                         
                                         if ((area->backend) &&
@@ -1008 +1008 @@
                                      ptr + P2SZ(size), false, &pte);
                                 
-                                assert(found);
-                                assert(PTE_VALID(&pte));
-                                assert(PTE_PRESENT(&pte));
+                                ASSERT(found);
+                                ASSERT(PTE_VALID(&pte));
+                                ASSERT(PTE_PRESENT(&pte));
                                 
                                 if ((area->backend) &&
@@ -1194 +1194 @@
 NO_TRACE bool as_area_check_access(as_area_t *area, pf_access_t access)
 {
-        assert(mutex_locked(&area->lock));
+        ASSERT(mutex_locked(&area->lock));
         
         int flagmap[] = {
@@ -1321 +1321 @@
                                     ptr + P2SZ(size), false, &pte);
                                 
-                                assert(found);
-                                assert(PTE_VALID(&pte));
-                                assert(PTE_PRESENT(&pte));
+                                ASSERT(found);
+                                ASSERT(PTE_VALID(&pte));
+                                ASSERT(PTE_PRESENT(&pte));
                                 
                                 old_frame[frame_idx++] = PTE_GET_FRAME(&pte);
@@ -1541 +1541 @@
          */
         if (old_as) {
-                assert(old_as->cpu_refcount);
+                ASSERT(old_as->cpu_refcount);
                 
                 if ((--old_as->cpu_refcount == 0) && (old_as != AS_KERNEL)) {
@@ -1550 +1550 @@
                          * ASID.
                          */
-                        assert(old_as->asid != ASID_INVALID);
+                        ASSERT(old_as->asid != ASID_INVALID);
                         
                         list_append(&old_as->inactive_as_with_asid_link,
@@ -1597 +1597 @@
 NO_TRACE unsigned int as_area_get_flags(as_area_t *area)
 {
-        assert(mutex_locked(&area->lock));
+        ASSERT(mutex_locked(&area->lock));
         
         return area_flags_to_page_flags(area->flags);
@@ -1615 +1615 @@
 NO_TRACE pte_t *page_table_create(unsigned int flags)
 {
-        assert(as_operations);
-        assert(as_operations->page_table_create);
+        ASSERT(as_operations);
+        ASSERT(as_operations->page_table_create);
         
         return as_operations->page_table_create(flags);
@@ -1630 +1630 @@
 NO_TRACE void page_table_destroy(pte_t *page_table)
 {
-        assert(as_operations);
-        assert(as_operations->page_table_destroy);
+        ASSERT(as_operations);
+        ASSERT(as_operations->page_table_destroy);
         
         as_operations->page_table_destroy(page_table);
@@ -1651 +1651 @@
 NO_TRACE void page_table_lock(as_t *as, bool lock)
 {
-        assert(as_operations);
-        assert(as_operations->page_table_lock);
+        ASSERT(as_operations);
+        ASSERT(as_operations->page_table_lock);
         
         as_operations->page_table_lock(as, lock);
@@ -1665 +1665 @@
 NO_TRACE void page_table_unlock(as_t *as, bool unlock)
 {
-        assert(as_operations);
-        assert(as_operations->page_table_unlock);
+        ASSERT(as_operations);
+        ASSERT(as_operations->page_table_unlock);
         
         as_operations->page_table_unlock(as, unlock);
@@ -1680 +1680 @@
 NO_TRACE bool page_table_locked(as_t *as)
 {
-        assert(as_operations);
-        assert(as_operations->page_table_locked);
+        ASSERT(as_operations);
+        ASSERT(as_operations->page_table_locked);
 
         return as_operations->page_table_locked(as);
@@ -1724 +1724 @@
 bool used_space_insert(as_area_t *area, uintptr_t page, size_t count)
 {
-        assert(mutex_locked(&area->lock));
-        assert(IS_ALIGNED(page, PAGE_SIZE));
-        assert(count);
+        ASSERT(mutex_locked(&area->lock));
+        ASSERT(IS_ALIGNED(page, PAGE_SIZE));
+        ASSERT(count);
         
         btree_node_t *leaf = NULL;
@@ -1737 +1737 @@
         }
 
-        assert(leaf != NULL);
+        ASSERT(leaf != NULL);
         
         if (!leaf->keys) {
@@ -2010 +2010 @@
 bool used_space_remove(as_area_t *area, uintptr_t page, size_t count)
 {
-        assert(mutex_locked(&area->lock));
-        assert(IS_ALIGNED(page, PAGE_SIZE));
-        assert(count);
+        ASSERT(mutex_locked(&area->lock));
+        ASSERT(IS_ALIGNED(page, PAGE_SIZE));
+        ASSERT(count);
         
         btree_node_t *leaf;
@@ -2257 +2257 @@
                         as_area_t *area = node->value[i];
                         
-                        assert(area_idx < area_cnt);
+                        ASSERT(area_idx < area_cnt);
                         mutex_lock(&area->lock);