change "nil/-1" to "null/0" to match prop. m-line

8 files changed, 82 insertions, 80 deletions

diff --git a/litmus/ikglp_lock.c b/litmus/ikglp_lock.c
index fe242c789318..59d7ee4f9fd1 100644
--- a/litmus/ikglp_lock.c
+++ b/litmus/ikglp_lock.c
@@ -192,8 +192,8 @@ static void print_donees(struct ikglp_semaphore *sem, struct binheap_node *n, in
                           padding,
                           donee_node->task->comm,
                           donee_node->task->pid,
-                          (donor) ? donor->comm : "nil",
-                          (donor) ? donor->pid : -1,
+                          (donor) ? donor->comm : "null",
+                          (donor) ? donor->pid : 0,
                           ikglp_get_idx(sem, donee_node->fq));
 
     if(n->left) print_donees(sem, n->left, depth+1);
@@ -493,8 +493,8 @@ static void ikglp_refresh_owners_prio_decrease(struct fifo_queue *fq,
 
                 if(litmus->__compare(new_max_eff_prio, BASE, owner, BASE)) {
                         TRACE_CUR("%s/%d has greater base priority than base priority of owner (%s/%d) of fq %d.\n",
-                                          (new_max_eff_prio) ? new_max_eff_prio->comm : "nil",
-                                          (new_max_eff_prio) ? new_max_eff_prio->pid : -1,
+                                          (new_max_eff_prio) ? new_max_eff_prio->comm : "null",
+                                          (new_max_eff_prio) ? new_max_eff_prio->pid : 0,
                                           owner->comm,
                                           owner->pid,
                                           ikglp_get_idx(sem, fq));
@@ -503,8 +503,8 @@ static void ikglp_refresh_owners_prio_decrease(struct fifo_queue *fq,
                 }
                 else {
                         TRACE_CUR("%s/%d has lesser base priority than base priority of owner (%s/%d) of fq %d.\n",
-                                          (new_max_eff_prio) ? new_max_eff_prio->comm : "nil",
-                                          (new_max_eff_prio) ? new_max_eff_prio->pid : -1,
+                                          (new_max_eff_prio) ? new_max_eff_prio->comm : "null",
+                                          (new_max_eff_prio) ? new_max_eff_prio->pid : 0,
                                           owner->comm,
                                           owner->pid,
                                           ikglp_get_idx(sem, fq));
@@ -889,8 +889,8 @@ static void ikglp_enqueue_on_donor(struct ikglp_semaphore *sem,
         }
         else {
                 TRACE_TASK(t, "No change in effective priority (it is %s/%d).\n",
-                                   (new_max_eff_prio) ? new_max_eff_prio->comm : "nil",
-                                   (new_max_eff_prio) ? new_max_eff_prio->pid : -1);
+                                   (new_max_eff_prio) ? new_max_eff_prio->comm : "null",
+                                   (new_max_eff_prio) ? new_max_eff_prio->pid : 0);
                 raw_spin_unlock(&tsk_rt(donee)->hp_blocked_tasks_lock);
                 unlock_fine_irqrestore(&sem->lock, flags);
         }
@@ -1078,9 +1078,9 @@ static ikglp_wait_state_t* ikglp_find_hp_waiter_to_steal(
                                           ikglp_get_idx(sem, &sem->fifo_queues[i]),
                                           sem->fifo_queues[i].hp_waiter->comm,
                                           sem->fifo_queues[i].hp_waiter->pid,
-                                          (fq) ? ikglp_get_idx(sem, fq) : -1,
-                                          (fq) ? ((fq->hp_waiter) ? fq->hp_waiter->comm : "nil") : "nilXX",
-                                          (fq) ? ((fq->hp_waiter) ? fq->hp_waiter->pid : -1) : -2);
+                                          (fq) ? ikglp_get_idx(sem, fq) : 0,
+                                          (fq) ? ((fq->hp_waiter) ? fq->hp_waiter->comm : "null") : "nullXX",
+                                          (fq) ? ((fq->hp_waiter) ? fq->hp_waiter->pid : 0) : -2);
 
                         fq = &sem->fifo_queues[i];
 
@@ -1151,8 +1151,8 @@ static void ikglp_steal_to_fq(struct ikglp_semaphore *sem,
                 fq_steal->hp_waiter = ikglp_find_hp_waiter(fq_steal, NULL);
                 TRACE_TASK(t, "New hp_waiter for fq %d is %s/%d!\n",
                                    ikglp_get_idx(sem, fq_steal),
-                                   (fq_steal->hp_waiter) ? fq_steal->hp_waiter->comm : "nil",
-                                   (fq_steal->hp_waiter) ? fq_steal->hp_waiter->pid : -1);
+                                   (fq_steal->hp_waiter) ? fq_steal->hp_waiter->comm : "null",
+                                   (fq_steal->hp_waiter) ? fq_steal->hp_waiter->pid : 0);
         }
 
 
@@ -1450,8 +1450,8 @@ int ikglp_unlock(struct litmus_lock* l)
                                 other_fq->hp_waiter = ikglp_find_hp_waiter(other_fq, NULL);
                                 TRACE_TASK(t, "New hp_waiter for fq %d is %s/%d!\n",
                                                    ikglp_get_idx(sem, other_fq),
-                                                   (other_fq->hp_waiter) ? other_fq->hp_waiter->comm : "nil",
-                                                   (other_fq->hp_waiter) ? other_fq->hp_waiter->pid : -1);
+                                                   (other_fq->hp_waiter) ? other_fq->hp_waiter->comm : "null",
+                                                   (other_fq->hp_waiter) ? other_fq->hp_waiter->pid : 0);
 
                                 ikglp_refresh_owners_prio_decrease(other_fq, sem, flags); // unlocks sem->lock.  reacquire it.
                                 lock_fine_irqsave(&sem->lock, flags);  // there should be no contention!!!!
@@ -1489,8 +1489,8 @@ int ikglp_unlock(struct litmus_lock* l)
 
                                 TRACE_TASK(t, "New hp_waiter for fq %d is %s/%d!\n",
                                                    ikglp_get_idx(sem, fq),
-                                                   (fq->hp_waiter) ? fq->hp_waiter->comm : "nil",
-                                                   (fq->hp_waiter) ? fq->hp_waiter->pid : -1);
+                                                   (fq->hp_waiter) ? fq->hp_waiter->comm : "null",
+                                                   (fq->hp_waiter) ? fq->hp_waiter->pid : 0);
                         }
                 }
                 else {
@@ -1536,8 +1536,8 @@ wake_kludge:
                         fq->hp_waiter = ikglp_find_hp_waiter(fq, NULL);
                         TRACE_TASK(next, "New hp_waiter for fq %d is %s/%d!\n",
                                            ikglp_get_idx(sem, fq),
-                                           (fq->hp_waiter) ? fq->hp_waiter->comm : "nil",
-                                           (fq->hp_waiter) ? fq->hp_waiter->pid : -1);
+                                           (fq->hp_waiter) ? fq->hp_waiter->comm : "null",
+                                           (fq->hp_waiter) ? fq->hp_waiter->pid : 0);
 
                         fq->nest.hp_waiter_eff_prio = (fq->hp_waiter) ?
                                                                 effective_priority(fq->hp_waiter) : NULL;
@@ -1568,8 +1568,8 @@ wake_kludge:
                          * waiter's priority. */
                         TRACE_TASK(next, "is not hp_waiter of replica %d. hp_waiter is %s/%d\n",
                                            ikglp_get_idx(sem, fq),
-                                           (fq->hp_waiter) ? fq->hp_waiter->comm : "nil",
-                                           (fq->hp_waiter) ? fq->hp_waiter->pid : -1);
+                                           (fq->hp_waiter) ? fq->hp_waiter->comm : "null",
+                                           (fq->hp_waiter) ? fq->hp_waiter->pid : 0);
 
                         raw_spin_lock(&tsk_rt(next)->hp_blocked_tasks_lock);
 
@@ -2166,8 +2166,8 @@ out:
 
         TRACE_CUR("Candidate victim from fq %d is %s/%d.  aff improvement = %d.\n",
                           replica,
-                          (wait) ? wait->task->comm : "nil",
-                          (wait) ? wait->task->pid  : -1,
+                          (wait) ? wait->task->comm : "null",
+                          (wait) ? wait->task->pid  : 0,
                           max_improvement);
 
         return wait;
@@ -2284,11 +2284,11 @@ static ikglp_donee_heap_node_t* pick_donee(struct ikglp_affinity* aff,
 //                                "(mth_highest != fq->owner) = %d "
 //                                "(mth_highest > fq->owner) = %d\n",
 //                                ikglp_get_idx(sem, fq),
-//                                (fq->owner) ? fq->owner->comm : "nil",
-//                                (fq->owner) ? fq->owner->pid : -1,
+//                                (fq->owner) ? fq->owner->comm : "null",
+//                                (fq->owner) ? fq->owner->pid : 0,
 //                                (fq->owner) ? (int)get_deadline(fq->owner) - now : -999,
-//                                (fq->donee_heap_node.donor_info) ? fq->donee_heap_node.donor_info->task->comm : "nil",
-//                                (fq->donee_heap_node.donor_info) ? fq->donee_heap_node.donor_info->task->pid : -1,
+//                                (fq->donee_heap_node.donor_info) ? fq->donee_heap_node.donor_info->task->comm : "null",
+//                                (fq->donee_heap_node.donor_info) ? fq->donee_heap_node.donor_info->task->pid : 0,
 //                                (mth_highest != fq->owner),
 //                                (litmus->__compare(mth_highest, BASE, fq->owner, BASE)));
 
@@ -2308,8 +2308,8 @@ static ikglp_donee_heap_node_t* pick_donee(struct ikglp_affinity* aff,
 //                                        dist_from_head,
 //                                        wait->task->comm, wait->task->pid,
 //                                        (int)get_deadline(wait->task) - now,
-//                                        (wait->donee_heap_node.donor_info) ? wait->donee_heap_node.donor_info->task->comm : "nil",
-//                                        (wait->donee_heap_node.donor_info) ? wait->donee_heap_node.donor_info->task->pid : -1,
+//                                        (wait->donee_heap_node.donor_info) ? wait->donee_heap_node.donor_info->task->comm : "null",
+//                                        (wait->donee_heap_node.donor_info) ? wait->donee_heap_node.donor_info->task->pid : 0,
 //                                        (mth_highest != wait->task),
 //                                        (litmus->__compare(mth_highest, BASE, wait->task, BASE)));
 
@@ -2342,8 +2342,8 @@ out:
 
         TRACE_CUR("Candidate donee for fq %d is %s/%d (dist_from_head = %d)\n",
                           ikglp_get_idx(sem, fq),
-                          (donee) ? (donee)->comm : "nil",
-                          (donee) ? (donee)->pid  : -1,
+                          (donee) ? (donee)->comm : "null",
+                          (donee) ? (donee)->pid  : 0,
                           *dist_from_head);
 
         return donee_node;
diff --git a/litmus/locking.c b/litmus/locking.c
index 81a1fc9bdd12..58b5edd9df32 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -218,12 +218,12 @@ void print_hp_waiters(struct binheap_node* n, int depth)
 
         TRACE("%s+-> %s/%d [waiter = %s/%d] [waiter's inh = %s/%d] (lock = %d)\n",
                   padding,
-                  (node_prio) ? node_prio->comm : "nil",
-                  (node_prio) ? node_prio->pid : -1,
-                  (hp) ? hp->comm : "nil",
-                  (hp) ? hp->pid : -1,
-                  (hp_eff) ? hp_eff->comm : "nil",
-                  (hp_eff) ? hp_eff->pid : -1,
+                  (node_prio) ? node_prio->comm : "null",
+                  (node_prio) ? node_prio->pid : 0,
+                  (hp) ? hp->comm : "null",
+                  (hp) ? hp->pid : 0,
+                  (hp_eff) ? hp_eff->comm : "null",
+                  (hp_eff) ? hp_eff->pid : 0,
                   l->ident);
 
     if(n->left) print_hp_waiters(n->left, depth+1);
diff --git a/litmus/nvidia_info.c b/litmus/nvidia_info.c
index ab62ca1b5b11..f5364df6fd69 100644
--- a/litmus/nvidia_info.c
+++ b/litmus/nvidia_info.c
@@ -517,11 +517,13 @@ struct task_struct* get_nv_max_device_owner(u32 target_device_id)
 
         reg = &NV_DEVICE_REG[target_device_id];
 
+#ifdef CONFIG_SCHED_DEBUG_TRACE
         if (!binheap_empty(&reg->owners)) {
                 struct task_struct *hp = container_of(binheap_top_entry(&reg->owners, struct rt_param, gpu_owner_node),
                                                                                           struct task_struct, rt_param);
                 TRACE_CUR("hp: %s/%d\n", hp->comm, hp->pid);
         }
+#endif
 
         return(owner);
 }
@@ -555,8 +557,8 @@ static int gpu_klmirqd_increase_priority(struct task_struct *klmirqd, struct tas
 
         TRACE_CUR("Increasing priority of %s/%d to %s/%d.\n",
                         klmirqd->comm, klmirqd->pid,
-                        (hp) ? hp->comm : "nil",
-                        (hp) ? hp->pid : -1);
+                        (hp) ? hp->comm : "null",
+                        (hp) ? hp->pid : 0);
 
         /* the klmirqd thread should never attempt to hold a litmus-level real-time
          * so nested support is not required */
@@ -571,8 +573,8 @@ static int gpu_klmirqd_decrease_priority(struct task_struct *klmirqd, struct tas
 
         TRACE_CUR("Decreasing priority of %s/%d to %s/%d.\n",
                         klmirqd->comm, klmirqd->pid,
-                        (hp) ? hp->comm : "nil",
-                        (hp) ? hp->pid : -1);
+                        (hp) ? hp->comm : "null",
+                        (hp) ? hp->pid : 0);
 
         /* the klmirqd thread should never attempt to hold a litmus-level real-time
          * so nested support is not required */
@@ -685,10 +687,10 @@ long disable_gpu_owner(struct task_struct *t)
                 TRACE_CUR("%s/%d is no longer hp on GPU %d; new hp = %s/%d (eff_prio = %s/%d).\n",
                                                 t->comm, t->pid,
                                                 gpu,
-                                                (new_hp) ? new_hp->comm : "nil",
-                                                (new_hp) ? new_hp->pid : -1,
-                                                (to_inh) ? to_inh->comm : "nil",
-                                                (to_inh) ? to_inh->pid : -1);
+                                                (new_hp) ? new_hp->comm : "null",
+                                                (new_hp) ? new_hp->pid : 0,
+                                                (to_inh) ? to_inh->comm : "null",
+                                                (to_inh) ? to_inh->pid : 0);
 
                 retval = gpu_klmirqd_decrease_priority(reg->thread, to_inh);
         }
diff --git a/litmus/rsm_lock.c b/litmus/rsm_lock.c
index dcf44a848cbb..beb2aa1a4f54 100644
--- a/litmus/rsm_lock.c
+++ b/litmus/rsm_lock.c
@@ -679,8 +679,8 @@ void rsm_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
                                 //if(__edf_higher_prio(new_max_eff_prio, BASE, owner, BASE)) {
                                 if(litmus->__compare(new_max_eff_prio, BASE, owner, BASE)) {
                                         TRACE_CUR("%s/%d has greater base priority than base priority of owner (%s/%d) of lock %d.\n",
-                                                          (new_max_eff_prio) ? new_max_eff_prio->comm : "nil",
-                                                          (new_max_eff_prio) ? new_max_eff_prio->pid : -1,
+                                                          (new_max_eff_prio) ? new_max_eff_prio->comm : "null",
+                                                          (new_max_eff_prio) ? new_max_eff_prio->pid : 0,
                                                           owner->comm,
                                                           owner->pid,
                                                           l->ident);
@@ -689,8 +689,8 @@ void rsm_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
                                 }
                                 else {
                                         TRACE_CUR("%s/%d has lesser base priority than base priority of owner (%s/%d) of lock %d.\n",
-                                                          (new_max_eff_prio) ? new_max_eff_prio->comm : "nil",
-                                                          (new_max_eff_prio) ? new_max_eff_prio->pid : -1,
+                                                          (new_max_eff_prio) ? new_max_eff_prio->comm : "null",
+                                                          (new_max_eff_prio) ? new_max_eff_prio->pid : 0,
                                                           owner->comm,
                                                           owner->pid,
                                                           l->ident);
@@ -812,26 +812,26 @@ static int rsm_proc_print(char *page, char **start, off_t off, int count, int *e
                 w = scnprintf(next, size,
                                                 "owner: %s/%d (inh: %s/%d)\n",
                                                         (mutex->owner) ?
-                                                                mutex->owner->comm : "nil",
+                                                                mutex->owner->comm : "null",
                                                         (mutex->owner) ?
-                                                                mutex->owner->pid : -1,
+                                                                mutex->owner->pid : 0,
                                                         (mutex->owner && tsk_rt(mutex->owner)->inh_task) ?
-                                                                tsk_rt(mutex->owner)->inh_task->comm : "nil",
+                                                                tsk_rt(mutex->owner)->inh_task->comm : "null",
                                                         (mutex->owner && tsk_rt(mutex->owner)->inh_task) ?
-                                                                tsk_rt(mutex->owner)->inh_task->pid : -1);
+                                                                tsk_rt(mutex->owner)->inh_task->pid : 0);
                 size -= w;
                 next += w;
 
                 w = scnprintf(next, size,
                                                 "hp waiter: %s/%d (inh: %s/%d)\n",
                                                         (mutex->hp_waiter) ?
-                                                                mutex->hp_waiter->comm : "nil",
+                                                                mutex->hp_waiter->comm : "null",
                                                         (mutex->hp_waiter) ?
-                                                                mutex->hp_waiter->pid : -1,
+                                                                mutex->hp_waiter->pid : 0,
                                                         (mutex->hp_waiter && tsk_rt(mutex->hp_waiter)->inh_task) ?
-                                                                tsk_rt(mutex->hp_waiter)->inh_task->comm : "nil",
+                                                                tsk_rt(mutex->hp_waiter)->inh_task->comm : "null",
                                                         (mutex->hp_waiter && tsk_rt(mutex->hp_waiter)->inh_task) ?
-                                                                tsk_rt(mutex->hp_waiter)->inh_task->pid : -1);
+                                                                tsk_rt(mutex->hp_waiter)->inh_task->pid : 0);
                 size -= w;
                 next += w;
 
@@ -875,9 +875,9 @@ static int rsm_proc_print(char *page, char **start, off_t off, int count, int *e
                                                 "\n",
                                                 blocked_task->comm, blocked_task->pid,
                                                 (tsk_rt(blocked_task)->inh_task) ?
-                                                        tsk_rt(blocked_task)->inh_task->comm : "nil",
+                                                        tsk_rt(blocked_task)->inh_task->comm : "null",
                                                 (tsk_rt(blocked_task)->inh_task) ?
-                                                        tsk_rt(blocked_task)->inh_task->pid : -1
+                                                        tsk_rt(blocked_task)->inh_task->pid : 0
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
                                                 , enabled
 #endif
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index 54322e278a1e..4528c4362ecf 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -304,7 +304,7 @@ void __add_ready(rt_domain_t* rt, struct task_struct *new)
                 "[inh_task: %s/%d (%llu, %llu %llu)] "
                 "rel=%llu to ready queue at %llu\n",
                 new->comm, new->pid, get_exec_cost(new), get_rt_period(new), get_rt_relative_deadline(new),
-                (tsk_rt(new)->inh_task) ? tsk_rt(new)->inh_task->comm : "(nil)",
+                (tsk_rt(new)->inh_task) ? tsk_rt(new)->inh_task->comm : "(null)",
                 (tsk_rt(new)->inh_task) ? tsk_rt(new)->inh_task->pid : 0,
                 (tsk_rt(new)->inh_task) ? get_exec_cost(tsk_rt(new)->inh_task) : 0,
                 (tsk_rt(new)->inh_task) ? get_rt_period(tsk_rt(new)->inh_task) : 0,
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 508a0596f9a7..df931de13e16 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -498,7 +498,7 @@ static void __do_lit_tasklet(struct tasklet_struct* tasklet, unsigned long flush
                 }
                 TRACE("%s: Invoking tasklet with owner pid = %d (flushed = %d).\n",
                           __FUNCTION__,
-                          (tasklet->owner) ? tasklet->owner->pid : -1,
+                          (tasklet->owner) ? tasklet->owner->pid : 0,
                           (tasklet->owner) ? 0 : 1);
                 tasklet->func(tasklet->data);
                 tasklet_unlock(tasklet);
@@ -1269,8 +1269,8 @@ static int __increase_priority_inheritance(struct task_struct* t,
                                    "Occurance is likely okay: probably due to (hopefully safe) concurrent priority updates.\n",
                                    t->comm, t->pid,
                                    effective_priority(t)->comm, effective_priority(t)->pid,
-                                   (prio_inh) ? prio_inh->comm : "nil",
-                                   (prio_inh) ? prio_inh->pid : -1);
+                                   (prio_inh) ? prio_inh->comm : "null",
+                                   (prio_inh) ? prio_inh->pid : 0);
                 WARN_ON(!prio_inh);
                 success = 0;
         }
@@ -1335,8 +1335,8 @@ static int __decrease_priority_inheritance(struct task_struct* t,
         if (prio_inh == tsk_rt(t)->inh_task) {
                 /* relationship already established. */
                 TRACE_TASK(t, "already inherits priority from %s/%d\n",
-                                   (prio_inh) ? prio_inh->comm : "(nil)",
-                                   (prio_inh) ? prio_inh->pid : -1);
+                                   (prio_inh) ? prio_inh->comm : "(null)",
+                                   (prio_inh) ? prio_inh->pid : 0);
                 goto out;
         }
 
@@ -1400,8 +1400,8 @@ static int __decrease_priority_inheritance(struct task_struct* t,
                                    "Occurance is likely okay: probably due to (hopefully safe) concurrent priority updates.\n",
                                    t->comm, t->pid,
                                    effective_priority(t)->comm, effective_priority(t)->pid,
-                                   (prio_inh) ? prio_inh->comm : "nil",
-                                   (prio_inh) ? prio_inh->pid : -1);
+                                   (prio_inh) ? prio_inh->comm : "null",
+                                   (prio_inh) ? prio_inh->pid : 0);
                 success = 0;
         }
 #endif
@@ -1418,8 +1418,8 @@ static void decrease_priority_inheritance(struct task_struct* t,
         raw_spin_lock(&cluster->cluster_lock);
 
         TRACE_TASK(t, "to inherit from %s/%d (decrease)\n",
-                        (prio_inh) ? prio_inh->comm : "nil",
-                        (prio_inh) ? prio_inh->pid : -1);
+                        (prio_inh) ? prio_inh->comm : "null",
+                        (prio_inh) ? prio_inh->pid : 0);
 
         __decrease_priority_inheritance(t, prio_inh);
 
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 8a8a6f1c306b..e290aed53d4d 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -212,8 +212,8 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
 
         /*
         if (print) {
-                TRACE_CUR("linked = %s/%d\n", (linked) ? linked->comm : "(nil)", (linked)? linked->pid : 0);
-                TRACE_CUR("entry->linked = %s/%d\n", (entry->linked) ? entry->linked->comm : "(nil)", (entry->linked)? entry->linked->pid : 0);
+                TRACE_CUR("linked = %s/%d\n", (linked) ? linked->comm : "(null)", (linked)? linked->pid : 0);
+                TRACE_CUR("entry->linked = %s/%d\n", (entry->linked) ? entry->linked->comm : "(null)", (entry->linked)? entry->linked->pid : 0);
         }
         */
 
@@ -481,7 +481,7 @@ static void __do_lit_tasklet(struct tasklet_struct* tasklet, unsigned long flush
                 }
                 TRACE("%s: Invoking tasklet with owner pid = %d (flushed = %d).\n",
                           __FUNCTION__,
-                          (tasklet->owner) ? tasklet->owner->pid : -1,
+                          (tasklet->owner) ? tasklet->owner->pid : 0,
                           (tasklet->owner) ? 0 : 1);
                 tasklet->func(tasklet->data);
                 tasklet_unlock(tasklet);
@@ -639,7 +639,7 @@ static void __add_pai_tasklet(struct tasklet_struct* tasklet)
 
                 // insert tasklet right before step->next.
 
-                TRACE("%s: inserting tasklet for %d between %d and %d.\n", __FUNCTION__, tasklet->owner->pid, step->owner->pid, (step->next) ? step->next->owner->pid : -1);
+                TRACE("%s: inserting tasklet for %d between %d and %d.\n", __FUNCTION__, tasklet->owner->pid, step->owner->pid, (step->next) ? step->next->owner->pid : 0);
 
                 tasklet->next = step->next;
                 step->next = tasklet;
@@ -1232,8 +1232,8 @@ static int __increase_priority_inheritance(struct task_struct* t,
                                           "Occurance is likely okay: probably due to (hopefully safe) concurrent priority updates.\n",
                                    t->comm, t->pid,
                                    effective_priority(t)->comm, effective_priority(t)->pid,
-                                   (prio_inh) ? prio_inh->comm : "nil",
-                                   (prio_inh) ? prio_inh->pid : -1);
+                                   (prio_inh) ? prio_inh->comm : "null",
+                                   (prio_inh) ? prio_inh->pid : 0);
                 WARN_ON(!prio_inh);
                 success = 0;
         }
@@ -1276,7 +1276,7 @@ static int __decrease_priority_inheritance(struct task_struct* t,
         if (prio_inh == tsk_rt(t)->inh_task) {
                 /* relationship already established. */
                 TRACE_TASK(t, "already inherits priority from %s/%d\n",
-                                   (prio_inh) ? prio_inh->comm : "(nil)",
+                                   (prio_inh) ? prio_inh->comm : "(null)",
                                    (prio_inh) ? prio_inh->pid : 0);
                 goto out;
         }
@@ -1341,8 +1341,8 @@ static int __decrease_priority_inheritance(struct task_struct* t,
                                    "Occurance is likely okay: probably due to (hopefully safe) concurrent priority updates.\n",
                                    t->comm, t->pid,
                                    effective_priority(t)->comm, effective_priority(t)->pid,
-                                   (prio_inh) ? prio_inh->comm : "nil",
-                                   (prio_inh) ? prio_inh->pid : -1);
+                                   (prio_inh) ? prio_inh->comm : "null",
+                                   (prio_inh) ? prio_inh->pid : 0);
                 success = 0;
         }
 #endif
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index e1654da1ea6c..e870fc14d4d3 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -32,8 +32,8 @@ void preempt_if_preemptable(struct task_struct* t, int cpu)
         int reschedule = 0;
 
         TRACE_CUR("preempt_if_preemptable: %s/%d\n",
-                                (t) ? t->comm : "(nil)",
-                                (t) ? t->pid : -1);
+                                (t) ? t->comm : "null",
+                                (t) ? t->pid : 0);
 
         if (!t) {
                 TRACE_CUR("unconditionally reschedule\n");