barry@barry-VirtualBox:~/development/linux-2.6$ sudo make install

sh /home/barry/development/linux-2.6/arch/x86/boot/install.sh 3.4.11-rt19 arch/x86/boot/bzImage \

System.map "/boot"

barry@barry-VirtualBox:~/development/linux-2.6$ sudo mkinitramfs 3.4.11-rt19 -o /boot/initrd.img-3.4.11-rt19

menuentry 'Ubuntu, with Linux 3.4.11-rt19' --class ubuntu --class gnu-linux --class gnu --class os {

   recordfail

   insmod part_msdos

   insmod ext2

   set root='(hd0,msdos1)'

   search --no-floppy --fs-uuid --set a0db5cf0-6ce3-404f-9808-88ce18f0177a

   linux    /boot/vmlinuz-3.4.11-rt19 root=UUID=a0db5cf0-6ce3-404f-9808-88ce18f0177a ro   quiet splash

   initrd    /boot/initrd.img-3.4.11-rt19

}

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <sched.h>

#include <sys/mman.h>

#include <string.h>

#define MY_PRIORITY (49) /* we use 49 as the PRREMPT_RT use 50

as the priority of kernel tasklets

and interrupt handler by default */

#define MAX_SAFE_STACK (8*1024) /* The maximum stack size which is

guaranteed safe to access without

faulting */

#define NSEC_PER_SEC    (1000000000) /* The number of nsecs per sec. */

void stack_prefault(void) {

unsigned char dummy[MAX_SAFE_STACK];

memset(dummy, 0, MAX_SAFE_STACK);

return;

}

int main(int argc, char* argv[])

{

struct timespec t;

struct sched_param param;

int interval = 50000; /* 50us*/

/* Declare ourself as a real time task */

param.sched_priority = MY_PRIORITY;

if(sched_setscheduler(0, SCHED_FIFO, ¶m) == -1) {

perror("sched_setscheduler failed");

exit(-1);

}

/* Lock memory */

if(mlockall(MCL_CURRENT|MCL_FUTURE) == -1) {

perror("mlockall failed");

exit(-2);

}

/* Pre-fault our stack */

stack_prefault();

clock_gettime(CLOCK_MONOTONIC ,&t);

/* start after one second */

t.tv_sec++;

while(1) {

/* wait until next shot */

clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &t, NULL);

/* do the stuff */

/* calculate next shot */

t.tv_nsec += interval;

while (t.tv_nsec >= NSEC_PER_SEC) {

t.tv_nsec -= NSEC_PER_SEC;

t.tv_sec++;

}

}

}

887 static int

888 __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)

889 {

890         ...

903

904         /*

905          * Check whether the interrupt nests into another interrupt

906          * thread.

907          */

908         nested = irq_settings_is_nested_thread(desc);

909         if (nested) {

910                 ...

920         } else {

921                 if (irq_settings_can_thread(desc))

922                         irq_setup_forced_threading(new);

923         }

925         /*

926          * Create a handler thread when a thread function is supplied

927          * and the interrupt does not nest into another interrupt

928          * thread.

929          */

930         if (new->thread_fn && !nested) {

931                 struct task_struct *t;

932

933                 t = kthread_create(irq_thread, new, "irq/%d-%s", irq,

934                                    new->name);

935                 ...

939                 /*

940                  * We keep the reference to the task struct even if

941                  * the thread dies to avoid that the interrupt code

942                  * references an already freed task_struct.

943                  */

944                 get_task_struct(t);

945                 new->thread = t;

946         }

133 handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)

134 {

135         irqreturn_t retval = IRQ_NONE;

136         unsigned int flags = 0, irq = desc->irq_data.irq;

137

138         do {

139                 irqreturn_t res;

140

141                 trace_irq_handler_entry(irq, action);

142                 res = action->handler(irq, action->dev_id);

143                 trace_irq_handler_exit(irq, action, res);

144

145                 if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",

146                               irq, action->handler))

147                         local_irq_disable();

148

149                 switch (res) {

150                 case IRQ_WAKE_THREAD:

151                         /*

152                          * Catch drivers which return WAKE_THREAD but

153                          * did not set up a thread function

154                          */

155                         if (unlikely(!action->thread_fn)) {

156                                 warn_no_thread(irq, action);

157                                 break;

158                         }

159

160                         irq_wake_thread(desc, action);

161

162                         /* Fall through to add to randomness */

163                 case IRQ_HANDLED:

164                         flags |= action->flags;

165                         break;

166

167                 default:

789 static int irq_thread(void *data)

790 {

791         static const struct sched_param param = {

792                 .sched_priority = MAX_USER_RT_PRIO/2,

793         };

794         struct irqaction *action = data;

795         struct irq_desc *desc = irq_to_desc(action->irq);

796         irqreturn_t (*handler_fn)(struct irq_desc *desc,

797                         struct irqaction *action);

798

799         if (force_irqthreads && test_bit(IRQTF_FORCED_THREAD,

800                                         &action->thread_flags))

801                 handler_fn = irq_forced_thread_fn;

802         else

803                 handler_fn = irq_thread_fn;

804

805         sched_setscheduler(current, SCHED_FIFO, ¶m);

806         current->irq_thread = 1;

807

808         while (!irq_wait_for_interrupt(action)) {

809                 irqreturn_t action_ret;

810

811                 irq_thread_check_affinity(desc, action);

812

813                 action_ret = handler_fn(desc, action);

814                 if (!noirqdebug)

815                         note_interrupt(action->irq, desc, action_ret);

816

817                 wake_threads_waitq(desc);

818         }

819

820         /*

821          * This is the regular exit path. __fr

Subject: arm: Mark pmu interupt IRQF_NO_THREAD

From: Thomas Gleixner <tglx@linutronix.de>

Date: Wed, 16 Mar 2011 14:45:31 +0100

PMU interrupt must not be threaded. Remove IRQF_DISABLED while at it

as we run all handlers with interrupts disabled anyway.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

---

arch/arm/kernel/perf_event.c |    2 +-

1 file changed, 1 insertion(+), 1 deletion(-)

Index: linux-stable/arch/arm/kernel/perf_event.c

===================================================================

--- linux-stable.orig/arch/arm/kernel/perf_event.c

+++ linux-stable/arch/arm/kernel/perf_event.c

@@ -430,7 +430,7 @@ armpmu_reserve_hardware(struct arm_pmu *

}

err = request_irq(irq, handle_irq,

-                                 IRQF_DISABLED | IRQF_NOBALANCING,

+                                 IRQF_NOBALANCING | IRQF_NO_THREAD,

"arm-pmu", armpmu);

if (err) {

r_err("unable to request IRQ%d for ARM PMU counters\n",

报名：《Linux任督二脉》之《进程调度》4节系列微课(5.22-25)