kernel: Use 'normal' types (i.e., uint8_t instead of __uint8_t).
authorSascha Wildner <saw@online.de>
Sat, 27 Jun 2015 16:24:58 +0000 (18:24 +0200)
committerSascha Wildner <saw@online.de>
Sat, 27 Jun 2015 17:06:09 +0000 (19:06 +0200)
sys/kern/kern_intr.c
sys/kern/kern_mutex.c
sys/kern/kern_slaballoc.c
sys/kern/lwkt_ipiq.c
sys/kern/lwkt_thread.c
sys/netinet/in_cksum.c
sys/platform/pc64/isa/clock.c
sys/vm/vm_map.c

index 92ddcf8..9754c70 100644 (file)
@@ -775,7 +775,7 @@ ithread_handler(void *arg)
 {
     struct intr_info *info;
     int use_limit;
-    __uint32_t lseconds;
+    uint32_t lseconds;
     int intr, cpuid = mycpuid;
     int mpheld;
     struct intrec **list;
index 3c7adfa..dc652fd 100644 (file)
@@ -64,9 +64,9 @@
 #include <sys/thread2.h>
 #include <sys/mutex2.h>
 
-static __int64_t mtx_contention_count;
-static __int64_t mtx_collision_count;
-static __int64_t mtx_wakeup_count;
+static int64_t mtx_contention_count;
+static int64_t mtx_collision_count;
+static int64_t mtx_wakeup_count;
 
 SYSCTL_QUAD(_kern, OID_AUTO, mtx_contention_count, CTLFLAG_RW,
            &mtx_contention_count, 0, "");
index 0823288..5bde0d6 100644 (file)
@@ -1393,7 +1393,7 @@ void
 chunk_mark_allocated(SLZone *z, void *chunk)
 {
     int bitdex = ((char *)chunk - (char *)z->z_BasePtr) / z->z_ChunkSize;
-    __uint32_t *bitptr;
+    uint32_t *bitptr;
 
     KKASSERT((((intptr_t)chunk ^ (intptr_t)z) & ZoneMask) == 0);
     KASSERT(bitdex >= 0 && bitdex < z->z_NMax,
@@ -1410,7 +1410,7 @@ void
 chunk_mark_free(SLZone *z, void *chunk)
 {
     int bitdex = ((char *)chunk - (char *)z->z_BasePtr) / z->z_ChunkSize;
-    __uint32_t *bitptr;
+    uint32_t *bitptr;
 
     KKASSERT((((intptr_t)chunk ^ (intptr_t)z) & ZoneMask) == 0);
     KASSERT(bitdex >= 0 && bitdex < z->z_NMax,
index 99c0836..7fc4d7f 100644 (file)
 #endif
 
 struct ipiq_stats {
-    __int64_t ipiq_count;      /* total calls to lwkt_send_ipiq*() */
-    __int64_t ipiq_fifofull;   /* number of fifo full conditions detected */
-    __int64_t ipiq_avoided;    /* interlock with target avoids cpu ipi */
-    __int64_t ipiq_passive;    /* passive IPI messages */
-    __int64_t ipiq_cscount;    /* number of cpu synchronizations */
+    int64_t ipiq_count;                /* total calls to lwkt_send_ipiq*() */
+    int64_t ipiq_fifofull;     /* number of fifo full conditions detected */
+    int64_t ipiq_avoided;      /* interlock with target avoids cpu ipi */
+    int64_t ipiq_passive;      /* passive IPI messages */
+    int64_t ipiq_cscount;      /* number of cpu synchronizations */
 } __cachealign;
 
 static struct ipiq_stats ipiq_stats_percpu[MAXCPU];
@@ -126,7 +126,7 @@ static void lwkt_cpusync_remote2(lwkt_cpusync_t cs);
 static int \
 sysctl_##name(SYSCTL_HANDLER_ARGS) \
 { \
-    __int64_t val = 0; \
+    int64_t val = 0; \
     int cpu, error; \
  \
     for (cpu = 0; cpu < ncpus; ++cpu) \
index b84b57b..3f8bb57 100644 (file)
@@ -89,10 +89,10 @@ static MALLOC_DEFINE(M_THREAD, "thread", "lwkt threads");
 #ifdef INVARIANTS
 static int panic_on_cscount = 0;
 #endif
-static __int64_t switch_count = 0;
-static __int64_t preempt_hit = 0;
-static __int64_t preempt_miss = 0;
-static __int64_t preempt_weird = 0;
+static int64_t switch_count = 0;
+static int64_t preempt_hit = 0;
+static int64_t preempt_miss = 0;
+static int64_t preempt_weird = 0;
 static int lwkt_use_spin_port;
 static struct objcache *thread_cache;
 int cpu_mwait_spin = 0;
@@ -238,7 +238,7 @@ _lwkt_enqueue(thread_t td)
     }
 }
 
-static __boolean_t
+static boolean_t
 _lwkt_thread_ctor(void *obj, void *privdata, int ocflags)
 {
        struct thread *td = (struct thread *)obj;
index 7bd63af..86d1f0f 100644 (file)
@@ -30,8 +30,6 @@
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
- *
- * $DragonFly: src/sys/netinet/in_cksum.c,v 1.9 2005/01/06 09:14:13 hsu Exp $
  */
 
 #include <sys/param.h>
  * carry when collapsing it back down to 16 bits.
  */
 
-__uint32_t
+uint32_t
 in_cksum_range(const struct mbuf *m, int nxt, int offset, int bytes)
 {
-    const __uint8_t *ptr;
-    __uint32_t sum0;
-    __uint32_t sum1;
+    const uint8_t *ptr;
+    uint32_t sum0;
+    uint32_t sum1;
     int n;
     int flip;
 
@@ -126,7 +124,7 @@ in_cksum_range(const struct mbuf *m, int nxt, int offset, int bytes)
         * Calculate pointer base and number of bytes to snarf, account
         * for snarfed bytes.
         */
-       ptr = mtod(m, const __uint8_t *) + offset;
+       ptr = mtod(m, const uint8_t *) + offset;
        if ((n = m->m_len - offset) > bytes)
            n = bytes;
        bytes -= n;
@@ -157,9 +155,9 @@ in_cksum_range(const struct mbuf *m, int nxt, int offset, int bytes)
        }
        if (((intptr_t)ptr & 2) && n > 1) {
            if (flip)
-               sum1 += *(const __uint16_t *)ptr;
+               sum1 += *(const uint16_t *)ptr;
            else
-               sum0 += *(const __uint16_t *)ptr;
+               sum0 += *(const uint16_t *)ptr;
            ptr += 2;
            n -= 2;
        }
@@ -169,7 +167,7 @@ in_cksum_range(const struct mbuf *m, int nxt, int offset, int bytes)
         * in sum0 or sum1.  Allow only one 16 bit overflow carry.
         */
        if (n >= 4) {
-           __uint32_t sum32;
+           uint32_t sum32;
 
            sum32 = asm_ones32((const void *)ptr, n >> 2);
            sum32 = (sum32 >> 16) + (sum32 & 0xffff);
@@ -187,9 +185,9 @@ in_cksum_range(const struct mbuf *m, int nxt, int offset, int bytes)
         */
        if (n & 2) {
            if (flip)
-               sum1 += *(const __uint16_t *)ptr;
+               sum1 += *(const uint16_t *)ptr;
            else
-               sum0 += *(const __uint16_t *)ptr;
+               sum0 += *(const uint16_t *)ptr;
            ptr += 2;
            /* n -= 2; dontcare */
        }
index 62e84cb..adb5c64 100644 (file)
@@ -276,14 +276,14 @@ static
 sysclock_t
 i8254_cputimer_count(void)
 {
-       static __uint16_t cputimer_last;
-       __uint16_t count;
+       static uint16_t cputimer_last;
+       uint16_t count;
        sysclock_t ret;
 
        clock_lock();
        outb(TIMER_MODE, i8254_walltimer_sel | TIMER_LATCH);
-       count = (__uint8_t)inb(i8254_walltimer_cntr);           /* get countdown */
-       count |= ((__uint8_t)inb(i8254_walltimer_cntr) << 8);
+       count = (uint8_t)inb(i8254_walltimer_cntr);             /* get countdown */
+       count |= ((uint8_t)inb(i8254_walltimer_cntr) << 8);
        count = -count;                                 /* -> countup */
        if (count < cputimer_last)                      /* rollover */
                i8254_cputimer.base += 0x00010000;
@@ -328,7 +328,7 @@ i8254_intr_config(struct cputimer_intr *cti, const struct cputimer *timer)
 static void
 i8254_intr_reload(struct cputimer_intr *cti, sysclock_t reload)
 {
-    __uint16_t count;
+    uint16_t count;
 
     if (i8254_cputimer_div)
        reload /= i8254_cputimer_div;
@@ -341,20 +341,20 @@ i8254_intr_reload(struct cputimer_intr *cti, sysclock_t reload)
     clock_lock();
     if (timer0_running) {
        outb(TIMER_MODE, TIMER_SEL0 | TIMER_LATCH);     /* count-down timer */
-       count = (__uint8_t)inb(TIMER_CNTR0);            /* lsb */
-       count |= ((__uint8_t)inb(TIMER_CNTR0) << 8);    /* msb */
+       count = (uint8_t)inb(TIMER_CNTR0);              /* lsb */
+       count |= ((uint8_t)inb(TIMER_CNTR0) << 8);      /* msb */
        if (reload < count) {
            outb(TIMER_MODE, TIMER_SEL0 | TIMER_SWSTROBE | TIMER_16BIT);
-           outb(TIMER_CNTR0, (__uint8_t)reload);       /* lsb */
-           outb(TIMER_CNTR0, (__uint8_t)(reload >> 8)); /* msb */
+           outb(TIMER_CNTR0, (uint8_t)reload);         /* lsb */
+           outb(TIMER_CNTR0, (uint8_t)(reload >> 8));  /* msb */
        }
     } else {
        timer0_running = 1;
        if (reload > 0xFFFF)
            reload = 0;         /* full count */
        outb(TIMER_MODE, TIMER_SEL0 | TIMER_SWSTROBE | TIMER_16BIT);
-       outb(TIMER_CNTR0, (__uint8_t)reload);           /* lsb */
-       outb(TIMER_CNTR0, (__uint8_t)(reload >> 8));    /* msb */
+       outb(TIMER_CNTR0, (uint8_t)reload);             /* lsb */
+       outb(TIMER_CNTR0, (uint8_t)(reload >> 8));      /* msb */
     }
     clock_unlock();
 }
@@ -1181,7 +1181,7 @@ static int
 hw_i8254_timestamp(SYSCTL_HANDLER_ARGS)
 {
     sysclock_t count;
-    __uint64_t tscval;
+    uint64_t tscval;
     char buf[32];
 
     crit_enter();
index f7ba1b1..3419ef1 100644 (file)
  * Virtual copy operations are performed by copying VM object references
  * from one map to another, and then marking both regions as copy-on-write.
  */
-static __boolean_t vmspace_ctor(void *obj, void *privdata, int ocflags);
+static boolean_t vmspace_ctor(void *obj, void *privdata, int ocflags);
 static void vmspace_dtor(void *obj, void *privdata);
 static void vmspace_terminate(struct vmspace *vm, int final);
 
@@ -209,7 +209,7 @@ vm_init2(void)
  * for performance reasons.
  */
 static
-__boolean_t
+boolean_t
 vmspace_ctor(void *obj, void *privdata, int ocflags)
 {
        struct vmspace *vm = obj;