/* * Called before incrementing preempt_count on {soft,}irq_enter * and before decrementing preempt_count on {soft,}irq_exit. */ void irqtime_account_irq(struct task_struct *curr) { unsigned long flags; s64 delta; int cpu; if (!sched_clock_irqtime) return; local_irq_save(flags); cpu = smp_processor_id(); delta = sched_clock_cpu(cpu) - __this_cpu_read(irq_start_time); __this_cpu_add(irq_start_time, delta); irq_time_write_begin(); /* * We do not account for softirq time from ksoftirqd here. * We want to continue accounting softirq time to ksoftirqd thread * in that case, so as not to confuse scheduler with a special task * that do not consume any time, but still wants to run. */ if (hardirq_count()) __this_cpu_add(cpu_hardirq_time, delta); else if (in_serving_softirq() && curr != this_cpu_ksoftirqd()) __this_cpu_add(cpu_softirq_time, delta); irq_time_write_end(); local_irq_restore(flags); }
/* * Called before incrementing preempt_count on {soft,}irq_enter * and before decrementing preempt_count on {soft,}irq_exit. */ void irqtime_account_irq(struct task_struct *curr) { struct irqtime *irqtime = this_cpu_ptr(&cpu_irqtime); s64 delta; int cpu; if (!sched_clock_irqtime) return; cpu = smp_processor_id(); delta = sched_clock_cpu(cpu) - irqtime->irq_start_time; irqtime->irq_start_time += delta; u64_stats_update_begin(&irqtime->sync); /* * We do not account for softirq time from ksoftirqd here. * We want to continue accounting softirq time to ksoftirqd thread * in that case, so as not to confuse scheduler with a special task * that do not consume any time, but still wants to run. */ if (hardirq_count()) irqtime->hardirq_time += delta; else if (in_serving_softirq() && curr != this_cpu_ksoftirqd()) irqtime->softirq_time += delta; u64_stats_update_end(&irqtime->sync); }
static void inline procfile_context_print(void) { printk_d("preemptible 0x%x\n", preemptible()); printk_d("in_atomic_preempt_off 0x%x\n", in_atomic_preempt_off()); printk_d("in_atomic 0x%x\n", in_atomic()); printk_d("in_nmi 0x%lx\n", in_nmi()); printk_d("in_serving_softirq 0x%lx\n", in_serving_softirq()); printk_d("in_interrupt 0x%lx\n", in_interrupt()); printk_d("in_softirq 0x%lx\n", in_softirq()); printk_d("in_irq 0x%lx\n", in_irq()); printk_d("preempt_count 0x%x\n", preempt_count()); printk_d("irqs_disabled 0x%x\n", irqs_disabled()); if(current) { printk_d("task->comm %s\n", current->comm); printk_d("task->flags 0x%x\n", current->flags); printk_d("task->state %lu\n", current->state); printk_d("task->usage %d\n", atomic_read(&(current->usage))); printk_d("task->prio %d\n", current->prio); printk_d("task->static_prio %d\n", current->static_prio); printk_d("task->normal_prio %d\n", current->normal_prio); printk_d("task->rt_priority %d\n", current->rt_priority); printk_d("task->policy %d\n", current->policy); printk_d("task->pid %d\n", current->pid); printk_d("task->tgid %d\n", current->tgid); } else printk_d("task pointer NULL\n"); }
void vtime_account_system(struct task_struct *tsk) { struct thread_info *ti = task_thread_info(tsk); __u64 stime = vtime_delta(tsk); if ((tsk->flags & PF_VCPU) && !irq_count()) ti->gtime += stime; else if (hardirq_count()) ti->hardirq_time += stime; else if (in_serving_softirq()) ti->softirq_time += stime; else ti->stime += stime; }
static int caam_qi_napi_schedule(struct qman_portal *p, struct caam_napi *np) { /* * In case of threaded ISR, for RT kernels in_irq() does not return * appropriate value, so use in_serving_softirq to distinguish between * softirq and irq contexts. */ if (unlikely(in_irq() || !in_serving_softirq())) { /* Disable QMan IRQ source and invoke NAPI */ qman_p_irqsource_remove(p, QM_PIRQ_DQRI); np->p = p; napi_schedule(&np->irqtask); return 1; } return 0; }
/* * Account system cpu time to a process. * @p: the process that the cpu time gets accounted to * @hardirq_offset: the offset to subtract from hardirq_count() * @cputime: the cpu time spent in kernel space since the last update */ void account_system_time(struct task_struct *p, int hardirq_offset, u64 cputime) { int index; if ((p->flags & PF_VCPU) && (irq_count() - hardirq_offset == 0)) { account_guest_time(p, cputime); return; } if (hardirq_count() - hardirq_offset) index = CPUTIME_IRQ; else if (in_serving_softirq()) index = CPUTIME_SOFTIRQ; else index = CPUTIME_SYSTEM; account_system_index_time(p, cputime, index); }
static int caam_qi_napi_schedule(struct qman_portal *p, struct caam_napi *np) { /* * In case of threaded ISR for RT enable kernel, * in_irq() does not return appropriate value, so use * in_serving_softirq to distinguish softirq or irq context. */ if (unlikely(in_irq() || !in_serving_softirq())) { /* Disable QMan IRQ source and invoke NAPI */ int ret = qman_p_irqsource_remove(p, QM_PIRQ_DQRI); if (likely(!ret)) { np->p = p; napi_schedule(&np->irqtask); return 1; } } return 0; }
void gr_handle_kernel_exploit(void) { #ifdef CONFIG_GRKERNSEC_KERN_LOCKOUT const struct cred *cred; struct task_struct *tsk, *tsk2; struct user_struct *user; uid_t uid; if (in_irq() || in_serving_softirq() || in_nmi()) panic("grsec: halting the system due to suspicious kernel crash caused in interrupt context"); uid = current_uid(); if (uid == 0) panic("grsec: halting the system due to suspicious kernel crash caused by root"); else { /* kill all the processes of this user, hold a reference to their creds struct, and prevent them from creating another process until system reset */ printk(KERN_ALERT "grsec: banning user with uid %u until system restart for suspicious kernel crash\n", uid); /* we intentionally leak this ref */ user = get_uid(current->cred->user); if (user) { user->banned = 1; user->ban_expires = ~0UL; } read_lock(&tasklist_lock); do_each_thread(tsk2, tsk) { cred = __task_cred(tsk); if (cred->uid == uid) gr_fake_force_sig(SIGKILL, tsk); } while_each_thread(tsk2, tsk); read_unlock(&tasklist_lock); }