xnu-3248.20.55.tar.gz

[apple/xnu.git] / osfmk / kern / timer_call.c

diff --git a/osfmk/kern/timer_call.c b/osfmk/kern/timer_call.c
index 56497e013e59bc2f81b25febdcfaaea36455a01a..fead4d66327ffd65a2dd7aa050b4eee75a7e0eb9 100644 (file)
--- a/osfmk/kern/timer_call.c
+++ b/osfmk/kern/timer_call.c
@@ -32,6 +32,7 @@
 #include <mach/mach_types.h>
 
 #include <kern/clock.h>
+#include <kern/smp.h>
 #include <kern/processor.h>
 #include <kern/timer_call.h>
 #include <kern/timer_queue.h>
@@ -73,13 +74,17 @@ lck_grp_t               timer_longterm_lck_grp;
 lck_attr_t              timer_longterm_lck_attr;
 lck_grp_attr_t          timer_longterm_lck_grp_attr;
 
-
+/* Timer queue lock must be acquired with interrupts disabled (under splclock()) */
+#if __SMP__
 #define timer_queue_lock_spin(queue)                                   \
        lck_mtx_lock_spin_always(&queue->lock_data)
 
 #define timer_queue_unlock(queue)              \
        lck_mtx_unlock_always(&queue->lock_data)
-
+#else
+#define timer_queue_lock_spin(queue)   (void)1
+#define timer_queue_unlock(queue)              (void)1
+#endif
 
 #define QUEUE(x)       ((queue_t)(x))
 #define MPQUEUE(x)     ((mpqueue_head_t *)(x))
@@ -412,9 +417,9 @@ timer_call_enqueue_deadline_unlocked(
 #if TIMER_ASSERT
                        TIMER_KDEBUG_TRACE(KDEBUG_TRACE, 
                                DECR_TIMER_ASYNC_DEQ | DBG_FUNC_NONE,
-                               call,
+                               VM_KERNEL_UNSLIDE_OR_PERM(call),
                                call->async_dequeue,
-                               TCE(call)->queue,
+                               VM_KERNEL_UNSLIDE_OR_PERM(TCE(call)->queue),
                                0x1c, 0);
                        timer_call_enqueue_deadline_unlocked_async1++;
 #endif
@@ -466,9 +471,9 @@ timer_call_dequeue_unlocked(
 #if TIMER_ASSERT
        TIMER_KDEBUG_TRACE(KDEBUG_TRACE, 
                DECR_TIMER_ASYNC_DEQ | DBG_FUNC_NONE,
-               call,
+               VM_KERNEL_UNSLIDE_OR_PERM(call),
                call->async_dequeue,
-               TCE(call)->queue,
+               VM_KERNEL_UNSLIDE_OR_PERM(TCE(call)->queue),
                0, 0);
 #endif
        if (old_queue != NULL) {
@@ -478,9 +483,9 @@ timer_call_dequeue_unlocked(
 #if TIMER_ASSERT
                        TIMER_KDEBUG_TRACE(KDEBUG_TRACE, 
                                DECR_TIMER_ASYNC_DEQ | DBG_FUNC_NONE,
-                               call,
+                           VM_KERNEL_UNSLIDE_OR_PERM(call),
                                call->async_dequeue,
-                               TCE(call)->queue,
+                               VM_KERNEL_UNSLIDE_OR_PERM(TCE(call)->queue),
                                0x1c, 0);
                        timer_call_dequeue_unlocked_async1++;
 #endif
@@ -565,8 +570,8 @@ timer_call_enter_internal(
 
        TIMER_KDEBUG_TRACE(KDEBUG_TRACE,
                DECR_TIMER_ENTER | DBG_FUNC_START,
-               call,
-               param1, deadline, flags, 0); 
+           VM_KERNEL_UNSLIDE_OR_PERM(call),
+           VM_KERNEL_UNSLIDE_OR_PERM(param1), deadline, flags, 0); 
 
        urgency = (flags & TIMER_CALL_URGENCY_MASK);
 
@@ -629,7 +634,7 @@ timer_call_enter_internal(
 
        TIMER_KDEBUG_TRACE(KDEBUG_TRACE,
                DECR_TIMER_ENTER | DBG_FUNC_END,
-               call,
+               VM_KERNEL_UNSLIDE_OR_PERM(call),
                (old_queue != NULL), deadline, queue->count, 0); 
 
        splx(s);
@@ -683,7 +688,7 @@ timer_call_cancel(
 
        TIMER_KDEBUG_TRACE(KDEBUG_TRACE,
                DECR_TIMER_CANCEL | DBG_FUNC_START,
-               call,
+               VM_KERNEL_UNSLIDE_OR_PERM(call),
                TCE(call)->deadline, call->soft_deadline, call->flags, 0);
 
        old_queue = timer_call_dequeue_unlocked(call);
@@ -703,8 +708,8 @@ timer_call_cancel(
        }
        TIMER_KDEBUG_TRACE(KDEBUG_TRACE,
                DECR_TIMER_CANCEL | DBG_FUNC_END,
-               call,
-               old_queue,
+               VM_KERNEL_UNSLIDE_OR_PERM(call),
+               VM_KERNEL_UNSLIDE_OR_PERM(old_queue),
                TCE(call)->deadline - mach_absolute_time(),
                TCE(call)->deadline - TCE(call)->entry_time, 0);
        splx(s);
@@ -749,9 +754,9 @@ timer_queue_shutdown(
 #if TIMER_ASSERT
                        TIMER_KDEBUG_TRACE(KDEBUG_TRACE, 
                                DECR_TIMER_ASYNC_DEQ | DBG_FUNC_NONE,
-                               call,
+                               VM_KERNEL_UNSLIDE_OR_PERM(call),
                                call->async_dequeue,
-                               TCE(call)->queue,
+                               VM_KERNEL_UNSLIDE_OR_PERM(TCE(call)->queue),
                                0x2b, 0);
 #endif
                        timer_queue_unlock(queue);
@@ -819,7 +824,7 @@ timer_queue_expire_with_options(
                        TCOAL_DEBUG(0xDDDD0000, queue->earliest_soft_deadline, call->soft_deadline, 0, 0, 0);
                        TIMER_KDEBUG_TRACE(KDEBUG_TRACE, 
                                DECR_TIMER_EXPIRE | DBG_FUNC_NONE,
-                               call,
+                               VM_KERNEL_UNSLIDE_OR_PERM(call),
                                call->soft_deadline,
                                TCE(call)->deadline,
                                TCE(call)->entry_time, 0);
@@ -849,7 +854,10 @@ timer_queue_expire_with_options(
 
                        TIMER_KDEBUG_TRACE(KDEBUG_TRACE, 
                                DECR_TIMER_CALLOUT | DBG_FUNC_START,
-                               call, VM_KERNEL_UNSLIDE(func), param0, param1, 0);
+                               VM_KERNEL_UNSLIDE_OR_PERM(call), VM_KERNEL_UNSLIDE(func),
+                               VM_KERNEL_UNSLIDE_OR_PERM(param0),
+                               VM_KERNEL_UNSLIDE_OR_PERM(param1),
+                               0);
 
 #if CONFIG_DTRACE
                        DTRACE_TMR7(callout__start, timer_call_func_t, func,
@@ -871,7 +879,10 @@ timer_queue_expire_with_options(
 
                        TIMER_KDEBUG_TRACE(KDEBUG_TRACE, 
                                DECR_TIMER_CALLOUT | DBG_FUNC_END,
-                               call, VM_KERNEL_UNSLIDE(func), param0, param1, 0);
+                               VM_KERNEL_UNSLIDE_OR_PERM(call), VM_KERNEL_UNSLIDE(func),
+                               VM_KERNEL_UNSLIDE_OR_PERM(param0),
+                               VM_KERNEL_UNSLIDE_OR_PERM(param1),
+                               0);
                        call = NULL;
                        timer_queue_lock_spin(queue);
                } else {
@@ -1008,9 +1019,9 @@ timer_queue_migrate(mpqueue_head_t *queue_from, mpqueue_head_t *queue_to)
 #ifdef TIMER_ASSERT
                        TIMER_KDEBUG_TRACE(KDEBUG_TRACE, 
                                DECR_TIMER_ASYNC_DEQ | DBG_FUNC_NONE,
-                               call,
-                               TCE(call)->queue,
-                               call->lock.interlock.lock_data,
+                               VM_KERNEL_UNSLIDE_OR_PERM(call),
+                               VM_KERNEL_UNSLIDE_OR_PERM(TCE(call)->queue),
+                               VM_KERNEL_UNSLIDE_OR_PERM(call->lock.interlock.lock_data),
                                0x2b, 0);
 #endif
                        timer_queue_migrate_lock_skips++;
@@ -1066,7 +1077,7 @@ timer_queue_trace(
                                call->soft_deadline,
                                TCE(call)->deadline,
                                TCE(call)->entry_time,
-                               TCE(call)->func,
+                               VM_KERNEL_UNSLIDE(TCE(call)->func),
                                0);
                        call = TIMER_CALL(queue_next(qe(call)));
                } while (!queue_end(&queue->head, qe(call)));
@@ -1218,9 +1229,9 @@ timer_longterm_scan(timer_longterm_t      *tlp,
 #ifdef TIMER_ASSERT
                        TIMER_KDEBUG_TRACE(KDEBUG_TRACE,
                                DECR_TIMER_ASYNC_DEQ | DBG_FUNC_NONE,
-                               call,
-                               TCE(call)->queue,
-                               call->lock.interlock.lock_data,
+                               VM_KERNEL_UNSLIDE_OR_PERM(call),
+                               VM_KERNEL_UNSLIDE_OR_PERM(TCE(call)->queue),
+                               VM_KERNEL_UNSLIDE_OR_PERM(call->lock.interlock.lock_data),
                                0x2c, 0);
 #endif
                        timer_call_entry_dequeue_async(call);
@@ -1235,7 +1246,7 @@ timer_longterm_scan(timer_longterm_t      *tlp,
                        if (deadline < now)
                                TIMER_KDEBUG_TRACE(KDEBUG_TRACE,
                                                DECR_TIMER_OVERDUE | DBG_FUNC_NONE,
-                                       call,
+                                       VM_KERNEL_UNSLIDE_OR_PERM(call),
                                        deadline,
                                        now,
                                        threshold,
@@ -1243,10 +1254,10 @@ timer_longterm_scan(timer_longterm_t    *tlp,
 #endif
                        TIMER_KDEBUG_TRACE(KDEBUG_TRACE,
                                        DECR_TIMER_ESCALATE | DBG_FUNC_NONE,
-                               call,
+                               VM_KERNEL_UNSLIDE_OR_PERM(call),
                                TCE(call)->deadline,
                                TCE(call)->entry_time,
-                               TCE(call)->func,
+                               VM_KERNEL_UNSLIDE(TCE(call)->func),
                                0);
                        tlp->escalates++;
                        timer_call_entry_dequeue(call);
@@ -1284,7 +1295,7 @@ timer_longterm_update_locked(timer_longterm_t *tlp)
 
        TIMER_KDEBUG_TRACE(KDEBUG_TRACE, 
                DECR_TIMER_UPDATE | DBG_FUNC_START,
-               &tlp->queue,
+               VM_KERNEL_UNSLIDE_OR_PERM(&tlp->queue),
                tlp->threshold.deadline,
                tlp->threshold.preempted,
                tlp->queue.count, 0);
@@ -1331,7 +1342,7 @@ timer_longterm_update_locked(timer_longterm_t *tlp)
 
        TIMER_KDEBUG_TRACE(KDEBUG_TRACE, 
                DECR_TIMER_UPDATE | DBG_FUNC_END,
-               &tlp->queue,
+               VM_KERNEL_UNSLIDE_OR_PERM(&tlp->queue),
                tlp->threshold.deadline,
                tlp->threshold.scans,
                tlp->queue.count, 0);