WebSVN – HelenOS – Path Comparison – / – /trunk/kernel Rev 3098 and /trunk/kernel Rev 3104

Ignore whitespace Rev 3098 → Rev 3104

 /trunk/kernel/test/mm/falloc2.c
 ,7 → 55,7
     uint8_t val = THREAD->tid % THREADS;
     index_t k;
-    uintptr_t * frames =  (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
+    void **frames =  (void **) malloc(MAX_FRAMES * sizeof(void *), FRAME_ATOMIC);
     if (frames == NULL) {
         if (!sh_quiet)
             printf("Thread #%" PRIu64 " (cpu%u): Unable to allocate frames\n", THREAD->tid, CPU->id);
 ,7 → 73,7
             allocated = 0;
             for (i = 0; i < (MAX_FRAMES >> order); i++) {
-                frames[allocated] = (uintptr_t)frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
+                frames[allocated] = frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
                 if (frames[allocated]) {
                     memsetb(frames[allocated], FRAME_SIZE << order, val);
                     allocated++;

 /trunk/kernel/test/mm/slab1.c
 ,7 → 53,7
     for (i = 0; i < count; i++) {
         data[i] = slab_alloc(cache, 0);
-        memsetb((uintptr_t) data[i], size, 0);
+        memsetb(data[i], size, 0);
     }
     if (!quiet) {
 ,7 → 71,7
     for (i = 0; i < count; i++) {
         data[i] = slab_alloc(cache, 0);
-        memsetb((uintptr_t) data[i], size, 0);
+        memsetb(data[i], size, 0);
     }
     if (!quiet) {
 ,7 → 89,7
     for (i = count / 2; i < count; i++) {
         data[i] = slab_alloc(cache, 0);
-        memsetb((uintptr_t) data[i], size, 0);
+        memsetb(data[i], size, 0);
     }
     if (!quiet) {

 /trunk/kernel/test/mm/slab2.c
 ,8 → 68,8
                 slab_free(cache2, data2);
             break;
         }
-        memsetb((uintptr_t) data1, ITEM_SIZE, 0);
-        memsetb((uintptr_t) data2, ITEM_SIZE, 0);
+        memsetb(data1, ITEM_SIZE, 0);
+        memsetb(data2, ITEM_SIZE, 0);
         *((void **) data1) = olddata1;
         *((void **) data2) = olddata2;
         olddata1 = data1;
 ,7 → 100,7
                 printf("Incorrect memory size - use another test.");
             return;
         }
-        memsetb((uintptr_t) data1, ITEM_SIZE, 0);
+        memsetb(data1, ITEM_SIZE, 0);
         *((void **) data1) = olddata1;
         olddata1 = data1;
     }
 ,7 → 108,7
         data1 = slab_alloc(cache1, FRAME_ATOMIC);
         if (!data1)
             break;
-        memsetb((uintptr_t) data1, ITEM_SIZE, 0);
+        memsetb(data1, ITEM_SIZE, 0);
         *((void **) data1) = olddata1;
         olddata1 = data1;
     }

 /trunk/kernel/genarch/src/mm/page_pt.c
 ,7 → 76,7
     if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT) {
         newpt = (pte_t *)frame_alloc(PTL1_SIZE, FRAME_KA);
-        memsetb((uintptr_t)newpt, FRAME_SIZE << PTL1_SIZE, 0);
+        memsetb(newpt, FRAME_SIZE << PTL1_SIZE, 0);
         SET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page), KA2PA(newpt));
         SET_PTL1_FLAGS(ptl0, PTL0_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
     }
 ,7 → 85,7
     if (GET_PTL2_FLAGS(ptl1, PTL1_INDEX(page)) & PAGE_NOT_PRESENT) {
         newpt = (pte_t *)frame_alloc(PTL2_SIZE, FRAME_KA);
-        memsetb((uintptr_t)newpt, FRAME_SIZE << PTL2_SIZE, 0);
+        memsetb(newpt, FRAME_SIZE << PTL2_SIZE, 0);
         SET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page), KA2PA(newpt));
         SET_PTL2_FLAGS(ptl1, PTL1_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
     }
 ,7 → 94,7
     if (GET_PTL3_FLAGS(ptl2, PTL2_INDEX(page)) & PAGE_NOT_PRESENT) {
         newpt = (pte_t *)frame_alloc(PTL3_SIZE, FRAME_KA);
-        memsetb((uintptr_t)newpt, FRAME_SIZE << PTL3_SIZE, 0);
+        memsetb(newpt, FRAME_SIZE << PTL3_SIZE, 0);
         SET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page), KA2PA(newpt));
         SET_PTL3_FLAGS(ptl2, PTL2_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
     }
 ,7 → 146,7
     ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
     /* Destroy the mapping. Setting to PAGE_NOT_PRESENT is not sufficient. */
-    memsetb((uintptr_t) &ptl3[PTL3_INDEX(page)], sizeof(pte_t), 0);
+    memsetb(&ptl3[PTL3_INDEX(page)], sizeof(pte_t), 0);
     /*
      * Second, free all empty tables along the way from PTL3 down to PTL0.
 ,11 → 166,11
          */
         frame_free(KA2PA((uintptr_t) ptl3));
         if (PTL2_ENTRIES)
-            memsetb((uintptr_t) &ptl2[PTL2_INDEX(page)], sizeof(pte_t), 0);
+            memsetb(&ptl2[PTL2_INDEX(page)], sizeof(pte_t), 0);
         else if (PTL1_ENTRIES)
-            memsetb((uintptr_t) &ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
+            memsetb(&ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
         else
-            memsetb((uintptr_t) &ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
+            memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
     } else {
         /*
          * PTL3 is not empty.
 ,9 → 195,9
              */
             frame_free(KA2PA((uintptr_t) ptl2));
             if (PTL1_ENTRIES)
-                memsetb((uintptr_t) &ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
+                memsetb(&ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
             else
-                memsetb((uintptr_t) &ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
+                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
         }
         else {
             /*
 ,7 → 223,7
              * Release the frame and remove PTL1 pointer from preceding table.
              */
             frame_free(KA2PA((uintptr_t) ptl1));
-            memsetb((uintptr_t) &ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
+            memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
         }
     }

 /trunk/kernel/genarch/src/mm/as_pt.c
 ,7 → 103,7
     table_size = FRAME_SIZE << PTL0_SIZE;
     if (flags & FLAG_AS_KERNEL) {
-        memsetb((uintptr_t) dst_ptl0, table_size, 0);
+        memsetb(dst_ptl0, table_size, 0);
     } else {
         uintptr_t src, dst;
 ,7 → 118,7
         src = (uintptr_t) &src_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
         dst = (uintptr_t) &dst_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
-        memsetb((uintptr_t) dst_ptl0, table_size, 0);
+        memsetb(dst_ptl0, table_size, 0);
         memcpy((void *) dst, (void *) src, table_size - (src - (uintptr_t) src_ptl0));
         mutex_unlock(&AS_KERNEL->lock);
         interrupts_restore(ipl);

 /trunk/kernel/generic/include/memstr.h
 ,8 → 42,8
  * Architecture independent variants.
  */
 extern void *_memcpy(void *dst, const void *src, size_t cnt);
-extern void _memsetb(uintptr_t dst, size_t cnt, uint8_t x);
-extern void _memsetw(uintptr_t dst, size_t cnt, uint16_t x);
+extern void _memsetb(void *dst, size_t cnt, uint8_t x);
+extern void _memsetw(void *dst, size_t cnt, uint16_t x);
 extern char *strcpy(char *dest, const char *src);
 #endif

 /trunk/kernel/generic/src/cpu/cpu.c
 ,7 → 67,7
             panic("malloc/cpus");
         /* initialize everything */
-        memsetb((uintptr_t) cpus, sizeof(cpu_t) * config.cpu_count, 0);
+        memsetb(cpus, sizeof(cpu_t) * config.cpu_count, 0);
         for (i = 0; i < config.cpu_count; i++) {
             cpus[i].stack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | FRAME_ATOMIC);

 /trunk/kernel/generic/src/proc/thread.c
 ,8 → 293,7
         return NULL;
     /* Not needed, but good for debugging */
-    memsetb((uintptr_t) t->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES,
-);
+    memsetb(t->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0);
     ipl = interrupts_disable();
     spinlock_lock(&tidlock);

 /trunk/kernel/generic/src/lib/memstr.c
 ,7 → 87,7
  * @param x   Value to fill.
  *
  */
-void _memsetb(uintptr_t dst, size_t cnt, uint8_t x)
+void _memsetb(void *dst, size_t cnt, uint8_t x)
 {
     unsigned int i;
     uint8_t *p = (uint8_t *) dst;
 ,7 → 106,7
  * @param x   Value to fill.
  *
  */
-void _memsetw(uintptr_t dst, size_t cnt, uint16_t x)
+void _memsetw(void *dst, size_t cnt, uint16_t x)
 {
     unsigned int i;
     uint16_t *p = (uint16_t *) dst;

 /trunk/kernel/generic/src/lib/objc_ext.c
 ,7 → 161,7
 void *memset(void *s, int c, size_t n)
 {
-    memsetb((uintptr_t) s, n, c);
+    memsetb(s, n, c);
     return s;
 }

 /trunk/kernel/generic/src/adt/hash_table.c
 ,7 → 63,7
     if (!h->entry) {
         panic("cannot allocate memory for hash table\n");
     }
-    memsetb((uintptr_t) h->entry, m * sizeof(link_t), 0);
+    memsetb(h->entry, m * sizeof(link_t), 0);
     for (i = 0; i < m; i++)
         list_initialize(&h->entry[i]);

 /trunk/kernel/generic/src/mm/slab.c
 ,8 → 559,7
     cache->mag_cache = malloc(sizeof(slab_mag_cache_t) * config.cpu_count,0);
     for (i = 0; i < config.cpu_count; i++) {
-        memsetb((uintptr_t)&cache->mag_cache[i],
-            sizeof(cache->mag_cache[i]), 0);
+        memsetb(&cache->mag_cache[i], sizeof(cache->mag_cache[i]), 0);
         spinlock_initialize(&cache->mag_cache[i].lock, "slab_maglock_cpu");
     }
 }
 ,7 → 577,7
     int pages;
     ipl_t ipl;
-    memsetb((uintptr_t)cache, sizeof(*cache), 0);
+    memsetb(cache, sizeof(*cache), 0);
     cache->name = name;
     if (align < sizeof(unative_t))

 /trunk/kernel/generic/src/mm/backend_anon.c
 ,7 → 113,7
             }
             if (allocate) {
                 frame = (uintptr_t) frame_alloc(ONE_FRAME, 0);
-                memsetb(PA2KA(frame), FRAME_SIZE, 0);
+                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
                 dirty = true;
                 /*
 ,7 → 144,7
          *   the different causes
          */
         frame = (uintptr_t) frame_alloc(ONE_FRAME, 0);
-        memsetb(PA2KA(frame), FRAME_SIZE, 0);
+        memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
         dirty = true;
     }

 /trunk/kernel/generic/src/mm/as.c
 ,8 → 324,7
     if (backend_data)
         a->backend_data = *backend_data;
     else
-        memsetb((uintptr_t) &a->backend_data, sizeof(a->backend_data),
-);
+        memsetb(&a->backend_data, sizeof(a->backend_data), 0);
     btree_create(&a->used_space);

 /trunk/kernel/generic/src/mm/backend_elf.c
 ,7 → 162,7
          * and cleared.
          */
         frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
-        memsetb(PA2KA(frame), FRAME_SIZE, 0);
+        memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
         dirty = true;
     } else {
         size_t pad_lo, pad_hi;
 ,8 → 187,8
         memcpy((void *) (PA2KA(frame) + pad_lo),
             (void *) (base + i * FRAME_SIZE + pad_lo),
             FRAME_SIZE - pad_lo - pad_hi);
-        memsetb(PA2KA(frame), pad_lo, 0);
-        memsetb(PA2KA(frame) + FRAME_SIZE - pad_hi, pad_hi, 0);
+        memsetb((void *) PA2KA(frame), pad_lo, 0);
+        memsetb((void *) (PA2KA(frame) + FRAME_SIZE - pad_hi), pad_hi, 0);
         dirty = true;
     }

 /trunk/kernel/generic/src/ipc/ipc.c
 ,7 → 66,7
  */
 static void _ipc_call_init(call_t *call)
 {
-    memsetb((uintptr_t) call, sizeof(*call), 0);
+    memsetb(call, sizeof(*call), 0);
     call->callerbox = &TASK->answerbox;
     call->sender = TASK;
     call->buffer = NULL;

 /trunk/kernel/Makefile
 ,7 → 34,7
 -include Makefile.config
 INCLUDES = generic/include
-OPTIMIZATION = 3
+OPTIMIZATION = 1
 ## Common compiler flags
 #

 /trunk/kernel/arch/sparc64/include/memstr.h
 ,10 → 37,10
 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
-extern void memsetw(uintptr_t dst, size_t cnt, uint16_t x);
-extern void memsetb(uintptr_t dst, size_t cnt, uint8_t x);
+extern void memsetw(void *dst, size_t cnt, uint16_t x);
+extern void memsetb(void *dst, size_t cnt, uint8_t x);
-extern int memcmp(uintptr_t src, uintptr_t dst, int cnt);
+extern int memcmp(const void *a, const void *b, size_t cnt);
 #endif

 /trunk/kernel/arch/sparc64/src/mm/as.c
 ,7 → 76,7
     as->arch.dtsb = (tsb_entry_t *) (tsb + ITSB_ENTRY_COUNT *
         sizeof(tsb_entry_t));
-    memsetb((uintptr_t) as->arch.itsb,
+    memsetb(as->arch.itsb,
         (ITSB_ENTRY_COUNT + DTSB_ENTRY_COUNT) * sizeof(tsb_entry_t), 0);
 #endif
     return 0;

 /trunk/kernel/arch/ia64/include/memstr.h
 ,10 → 37,10
 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
-extern void memsetw(uintptr_t dst, size_t cnt, uint16_t x);
-extern void memsetb(uintptr_t dst, size_t cnt, uint8_t x);
+extern void memsetw(void *dst, size_t cnt, uint16_t x);
+extern void memsetb(void *dst, size_t cnt, uint8_t x);
-extern int memcmp(uintptr_t src, uintptr_t dst, int cnt);
+extern int memcmp(const void *a, const void *b, size_t cnt);
 #endif

 /trunk/kernel/arch/ia64/src/mm/vhpt.c
 ,7 → 81,7
 void vhpt_invalidate_all()
 {
-    memsetb((uintptr_t) vhpt_base, 1 << VHPT_WIDTH, 0);
+    memsetb(vhpt_base, 1 << VHPT_WIDTH, 0);
 }
 void vhpt_invalidate_asid(asid_t asid)

 /trunk/kernel/arch/ia64/src/drivers/ega.c
 ,7 → 71,7
     /*
      * Clear the screen.
      */
-    _memsetw((uintptr_t) videoram, SCREEN, 0x0720);
+    _memsetw(videoram, SCREEN, 0x0720);
     chardev_initialize("ega_out", &ega_console, &ega_ops);
     stdout = &ega_console;
 ,7 → 102,7
         return;
     memcpy((void *) videoram, (void *) (videoram + ROW * 2), (SCREEN - ROW) * 2);
-    _memsetw((uintptr_t) (videoram + (SCREEN - ROW) * 2), ROW, 0x0720);
+    _memsetw(videoram + (SCREEN - ROW) * 2, ROW, 0x0720);
     ega_cursor = ega_cursor - ROW;
 }

 /trunk/kernel/arch/arm32/include/memstr.h
 ,10 → 38,10
 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
-extern void memsetw(uintptr_t dst, size_t cnt, uint16_t x);
-extern void memsetb(uintptr_t dst, size_t cnt, uint8_t x);
+extern void memsetw(void *dst, size_t cnt, uint16_t x);
+extern void memsetb(void *dst, size_t cnt, uint8_t x);
-extern int memcmp(uintptr_t src, uintptr_t dst, int cnt);
+extern int memcmp(const void *a, const void *b, size_t cnt);
 #endif

 /trunk/kernel/arch/ppc32/include/memstr.h
 ,10 → 37,10
 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
-extern void memsetw(uintptr_t dst, size_t cnt, uint16_t x);
-extern void memsetb(uintptr_t dst, size_t cnt, uint8_t x);
+extern void memsetw(void *dst, size_t cnt, uint16_t x);
+extern void memsetb(void *dst, size_t cnt, uint8_t x);
-extern int memcmp(uintptr_t src, uintptr_t dst, int cnt);
+extern int memcmp(const void *a, const void *b, size_t cnt);
 #endif

 /trunk/kernel/arch/ia32xen/src/ia32xen.c
 ,7 → 69,7
 void arch_pre_main(void)
 {
     pte_t pte;
-    memsetb((uintptr_t) &pte, sizeof(pte), 0);
+    memsetb(&pte, sizeof(pte), 0);
     pte.present = 1;
     pte.writeable = 1;
 ,7 → 103,7
             uintptr_t tpa = PFN2ADDR(meminfo.start + meminfo.reserved);
             uintptr_t tva = PA2KA(tpa);
-            memsetb(tva, PAGE_SIZE, 0);
+            memsetb((void *) tva, PAGE_SIZE, 0);
             pte_t *tptl3 = (pte_t *) PA2KA(GET_PTL1_ADDRESS(start_info.ptl0, PTL0_INDEX(tva)));
             SET_FRAME_ADDRESS(tptl3, PTL3_INDEX(tva), 0);

 /trunk/kernel/arch/ia32xen/src/pm.c
 ,7 → 98,7
 void tss_initialize(tss_t *t)
 {
-    memsetb((uintptr_t) t, sizeof(struct tss), 0);
+    memsetb(t, sizeof(struct tss), 0);
 }
 static void trap(void)

 /trunk/kernel/arch/ia32xen/src/smp/smp.c
 ,7 → 146,7
             panic("couldn't allocate memory for GDT\n");
         memcpy(gdt_new, gdt, GDT_ITEMS * sizeof(struct descriptor));
-        memsetb((uintptr_t)(&gdt_new[TSS_DES]), sizeof(struct descriptor), 0);
+        memsetb(&gdt_new[TSS_DES], sizeof(struct descriptor), 0);
         gdtr.base = (uintptr_t) gdt_new;
         if (l_apic_send_init_ipi(ops->cpu_apic_id(i))) {

 /trunk/kernel/arch/amd64/include/memstr.h
 ,10 → 37,10
 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
-extern void memsetw(uintptr_t dst, size_t cnt, uint16_t x);
-extern void memsetb(uintptr_t dst, size_t cnt, uint8_t x);
+extern void memsetw(void *dst, size_t cnt, uint16_t x);
+extern void memsetb(void *dst, size_t cnt, uint8_t x);
-extern int memcmp(uintptr_t src, uintptr_t dst, int cnt);
+extern int memcmp(const void *a, const void *b, size_t cnt);
 #endif

 /trunk/kernel/arch/amd64/src/pm.c
 ,7 → 155,7
 void tss_initialize(tss_t *t)
 {
-    memsetb((uintptr_t) t, sizeof(tss_t), 0);
+    memsetb(t, sizeof(tss_t), 0);
 }
 /*
 ,7 → 239,7
     preemption_disable();
     ipl_t ipl = interrupts_disable();
-    memsetb((uintptr_t) idt, sizeof(idt), 0);
+    memsetb(idt, sizeof(idt), 0);
     idtr_load(&idtr);
     interrupts_restore(ipl);

 /trunk/kernel/arch/ppc64/include/memstr.h
 ,10 → 37,10
 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
-extern void memsetw(uintptr_t dst, size_t cnt, uint16_t x);
-extern void memsetb(uintptr_t dst, size_t cnt, uint8_t x);
+extern void memsetw(void *dst, size_t cnt, uint16_t x);
+extern void memsetb(void *dst, size_t cnt, uint8_t x);
-extern int memcmp(uintptr_t src, uintptr_t dst, int cnt);
+extern int memcmp(const void *a, const void *b, size_t cnt);
 #endif

 /trunk/kernel/arch/ppc64/src/mm/page.c
 ,7 → 252,7
 void pht_init(void)
 {
-    memsetb((uintptr_t) phte, 1 << PHT_BITS, 0);
+    memsetb(phte, 1 << PHT_BITS, 0);
 }

 /trunk/kernel/arch/mips32/include/memstr.h
 ,10 → 37,10
 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
-extern void memsetw(uintptr_t dst, size_t cnt, uint16_t x);
-extern void memsetb(uintptr_t dst, size_t cnt, uint8_t x);
+extern void memsetw(void *dst, size_t cnt, uint16_t x);
+extern void memsetb(void *dst, size_t cnt, uint8_t x);
-extern int memcmp(uintptr_t src, uintptr_t dst, int cnt);
+extern int memcmp(const void *a, const void *b, size_t cnt);
 #endif

 /trunk/kernel/arch/ia32/include/memstr.h
 ,10 → 37,10
 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
-extern void memsetw(uintptr_t dst, size_t cnt, uint16_t x);
-extern void memsetb(uintptr_t dst, size_t cnt, uint8_t x);
+extern void memsetw(void *dst, size_t cnt, uint16_t x);
+extern void memsetb(void *dst, size_t cnt, uint8_t x);
-extern int memcmp(uintptr_t src, uintptr_t dst, int cnt);
+extern int memcmp(const void *a, const void *b, size_t cnt);
 #endif

 /trunk/kernel/arch/ia32/src/pm.c
 ,7 → 112,7
 void tss_initialize(tss_t *t)
 {
-    memsetb((uintptr_t) t, sizeof(struct tss), 0);
+    memsetb(t, sizeof(struct tss), 0);
 }
 /*
 ,7 → 240,7
     preemption_disable();
     ipl_t ipl = interrupts_disable();
-    memsetb((uintptr_t) idt, sizeof(idt), 0);
+    memsetb(idt, sizeof(idt), 0);
     ptr_16_32_t idtr;
     idtr.limit = sizeof(idt);

 /trunk/kernel/arch/ia32/src/smp/smp.c
 ,8 → 160,7
             panic("couldn't allocate memory for GDT\n");
         memcpy(gdt_new, gdt, GDT_ITEMS * sizeof(struct descriptor));
-        memsetb((uintptr_t)(&gdt_new[TSS_DES]),
-            sizeof(struct descriptor), 0);
+        memsetb(&gdt_new[TSS_DES], sizeof(struct descriptor), 0);
         protected_ap_gdtr.limit = GDT_ITEMS * sizeof(struct descriptor);
         protected_ap_gdtr.base = KA2PA((uintptr_t) gdt_new);
         gdtr.base = (uintptr_t) gdt_new;

 /trunk/kernel/arch/ia32/src/drivers/ega.c
 ,7 → 115,7
         return;
     memcpy((void *) videoram, (void *) (videoram + ROW * 2), (SCREEN - ROW) * 2);
-    memsetw((uintptr_t) (videoram + (SCREEN - ROW) * 2), ROW, 0x0720);
+    memsetw(videoram + (SCREEN - ROW) * 2, ROW, 0x0720);
     ega_cursor = ega_cursor - ROW;
 }

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3098 → Rev 3104