2 * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
3 * Licensed under the GPL
4 * Derived (i.e. mostly copied) from arch/i386/kernel/irq.c:
5 * Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
8 #include "linux/kernel.h"
9 #include "linux/module.h"
10 #include "linux/smp.h"
11 #include "linux/kernel_stat.h"
12 #include "linux/interrupt.h"
13 #include "linux/random.h"
14 #include "linux/slab.h"
15 #include "linux/file.h"
16 #include "linux/proc_fs.h"
17 #include "linux/init.h"
18 #include "linux/seq_file.h"
19 #include "linux/profile.h"
20 #include "linux/hardirq.h"
22 #include "asm/hw_irq.h"
23 #include "asm/atomic.h"
24 #include "asm/signal.h"
25 #include "asm/system.h"
26 #include "asm/errno.h"
27 #include "asm/uaccess.h"
28 #include "kern_util.h"
33 #include "misc_constants.h"
34 #include "as-layout.h"
37 * Generic, controller-independent functions:
40 int show_interrupts(struct seq_file
*p
, void *v
)
42 int i
= *(loff_t
*) v
, j
;
43 struct irqaction
* action
;
48 for_each_online_cpu(j
)
49 seq_printf(p
, "CPU%d ",j
);
54 spin_lock_irqsave(&irq_desc
[i
].lock
, flags
);
55 action
= irq_desc
[i
].action
;
58 seq_printf(p
, "%3d: ",i
);
60 seq_printf(p
, "%10u ", kstat_irqs(i
));
62 for_each_online_cpu(j
)
63 seq_printf(p
, "%10u ", kstat_cpu(j
).irqs
[i
]);
65 seq_printf(p
, " %14s", irq_desc
[i
].chip
->typename
);
66 seq_printf(p
, " %s", action
->name
);
68 for (action
=action
->next
; action
; action
= action
->next
)
69 seq_printf(p
, ", %s", action
->name
);
73 spin_unlock_irqrestore(&irq_desc
[i
].lock
, flags
);
74 } else if (i
== NR_IRQS
) {
82 * This list is accessed under irq_lock, except in sigio_handler,
83 * where it is safe from being modified. IRQ handlers won't change it -
84 * if an IRQ source has vanished, it will be freed by free_irqs just
85 * before returning from sigio_handler. That will process a separate
86 * list of irqs to free, with its own locking, coming back here to
87 * remove list elements, taking the irq_lock to do so.
89 static struct irq_fd
*active_fds
= NULL
;
90 static struct irq_fd
**last_irq_ptr
= &active_fds
;
92 extern void free_irqs(void);
94 void sigio_handler(int sig
, union uml_pt_regs
*regs
)
96 struct irq_fd
*irq_fd
;
99 if (smp_sigio_handler())
103 n
= os_waiting_for_events(active_fds
);
105 if(n
== -EINTR
) continue;
109 for (irq_fd
= active_fds
; irq_fd
!= NULL
; irq_fd
= irq_fd
->next
) {
110 if (irq_fd
->current_events
!= 0) {
111 irq_fd
->current_events
= 0;
112 do_IRQ(irq_fd
->irq
, regs
);
120 static DEFINE_SPINLOCK(irq_lock
);
122 int activate_fd(int irq
, int fd
, int type
, void *dev_id
)
124 struct pollfd
*tmp_pfd
;
125 struct irq_fd
*new_fd
, *irq_fd
;
127 int pid
, events
, err
, n
;
130 err
= os_set_fd_async(fd
, pid
);
135 new_fd
= kmalloc(sizeof(struct irq_fd
), GFP_KERNEL
);
139 if (type
== IRQ_READ
)
140 events
= UM_POLLIN
| UM_POLLPRI
;
143 *new_fd
= ((struct irq_fd
) { .next
= NULL
,
150 .current_events
= 0 } );
153 spin_lock_irqsave(&irq_lock
, flags
);
154 for (irq_fd
= active_fds
; irq_fd
!= NULL
; irq_fd
= irq_fd
->next
) {
155 if ((irq_fd
->fd
== fd
) && (irq_fd
->type
== type
)) {
156 printk("Registering fd %d twice\n", fd
);
157 printk("Irqs : %d, %d\n", irq_fd
->irq
, irq
);
158 printk("Ids : 0x%p, 0x%p\n", irq_fd
->id
, dev_id
);
163 if (type
== IRQ_WRITE
)
170 n
= os_create_pollfd(fd
, events
, tmp_pfd
, n
);
175 * It means we couldn't put new pollfd to current pollfds
176 * and tmp_fds is NULL or too small for new pollfds array.
177 * Needed size is equal to n as minimum.
179 * Here we have to drop the lock in order to call
180 * kmalloc, which might sleep.
181 * If something else came in and changed the pollfds array
182 * so we will not be able to put new pollfd struct to pollfds
183 * then we free the buffer tmp_fds and try again.
185 spin_unlock_irqrestore(&irq_lock
, flags
);
188 tmp_pfd
= kmalloc(n
, GFP_KERNEL
);
192 spin_lock_irqsave(&irq_lock
, flags
);
195 *last_irq_ptr
= new_fd
;
196 last_irq_ptr
= &new_fd
->next
;
198 spin_unlock_irqrestore(&irq_lock
, flags
);
200 /* This calls activate_fd, so it has to be outside the critical
203 maybe_sigio_broken(fd
, (type
== IRQ_READ
));
208 spin_unlock_irqrestore(&irq_lock
, flags
);
215 static void free_irq_by_cb(int (*test
)(struct irq_fd
*, void *), void *arg
)
219 spin_lock_irqsave(&irq_lock
, flags
);
220 os_free_irq_by_cb(test
, arg
, active_fds
, &last_irq_ptr
);
221 spin_unlock_irqrestore(&irq_lock
, flags
);
229 static int same_irq_and_dev(struct irq_fd
*irq
, void *d
)
231 struct irq_and_dev
*data
= d
;
233 return ((irq
->irq
== data
->irq
) && (irq
->id
== data
->dev
));
236 void free_irq_by_irq_and_dev(unsigned int irq
, void *dev
)
238 struct irq_and_dev data
= ((struct irq_and_dev
) { .irq
= irq
,
241 free_irq_by_cb(same_irq_and_dev
, &data
);
244 static int same_fd(struct irq_fd
*irq
, void *fd
)
246 return (irq
->fd
== *((int *)fd
));
249 void free_irq_by_fd(int fd
)
251 free_irq_by_cb(same_fd
, &fd
);
254 /* Must be called with irq_lock held */
255 static struct irq_fd
*find_irq_by_fd(int fd
, int irqnum
, int *index_out
)
261 for (irq
= active_fds
; irq
!= NULL
; irq
= irq
->next
) {
262 if ((irq
->fd
== fd
) && (irq
->irq
== irqnum
))
267 printk("find_irq_by_fd doesn't have descriptor %d\n", fd
);
270 fdi
= os_get_pollfd(i
);
271 if ((fdi
!= -1) && (fdi
!= fd
)) {
272 printk("find_irq_by_fd - mismatch between active_fds and "
273 "pollfds, fd %d vs %d, need %d\n", irq
->fd
,
283 void reactivate_fd(int fd
, int irqnum
)
289 spin_lock_irqsave(&irq_lock
, flags
);
290 irq
= find_irq_by_fd(fd
, irqnum
, &i
);
292 spin_unlock_irqrestore(&irq_lock
, flags
);
295 os_set_pollfd(i
, irq
->fd
);
296 spin_unlock_irqrestore(&irq_lock
, flags
);
301 void deactivate_fd(int fd
, int irqnum
)
307 spin_lock_irqsave(&irq_lock
, flags
);
308 irq
= find_irq_by_fd(fd
, irqnum
, &i
);
310 spin_unlock_irqrestore(&irq_lock
, flags
);
314 os_set_pollfd(i
, -1);
315 spin_unlock_irqrestore(&irq_lock
, flags
);
321 * Called just before shutdown in order to provide a clean exec
322 * environment in case the system is rebooting. No locking because
323 * that would cause a pointless shutdown hang if something hadn't
326 int deactivate_all_fds(void)
331 for (irq
= active_fds
; irq
!= NULL
; irq
= irq
->next
) {
332 err
= os_clear_fd_async(irq
->fd
);
336 /* If there is a signal already queued, after unblocking ignore it */
342 #ifdef CONFIG_MODE_TT
343 void forward_interrupts(int pid
)
349 spin_lock_irqsave(&irq_lock
, flags
);
350 for (irq
= active_fds
; irq
!= NULL
; irq
= irq
->next
) {
351 err
= os_set_owner(irq
->fd
, pid
);
353 /* XXX Just remove the irq rather than
354 * print out an infinite stream of these
356 printk("Failed to forward %d to pid %d, err = %d\n",
362 spin_unlock_irqrestore(&irq_lock
, flags
);
367 * do_IRQ handles all normal device IRQ's (the special
368 * SMP cross-CPU interrupts have their own specific
371 unsigned int do_IRQ(int irq
, union uml_pt_regs
*regs
)
373 struct pt_regs
*old_regs
= set_irq_regs((struct pt_regs
*)regs
);
377 set_irq_regs(old_regs
);
381 int um_request_irq(unsigned int irq
, int fd
, int type
,
382 irq_handler_t handler
,
383 unsigned long irqflags
, const char * devname
,
388 err
= request_irq(irq
, handler
, irqflags
, devname
, dev_id
);
393 err
= activate_fd(irq
, fd
, type
, dev_id
);
396 EXPORT_SYMBOL(um_request_irq
);
397 EXPORT_SYMBOL(reactivate_fd
);
399 /* hw_interrupt_type must define (startup || enable) &&
400 * (shutdown || disable) && end */
401 static void dummy(unsigned int irq
)
405 /* This is used for everything else than the timer. */
406 static struct hw_interrupt_type normal_irq_type
= {
408 .release
= free_irq_by_irq_and_dev
,
415 static struct hw_interrupt_type SIGVTALRM_irq_type
= {
416 .typename
= "SIGVTALRM",
417 .release
= free_irq_by_irq_and_dev
,
418 .shutdown
= dummy
, /* never called */
425 void __init
init_IRQ(void)
429 irq_desc
[TIMER_IRQ
].status
= IRQ_DISABLED
;
430 irq_desc
[TIMER_IRQ
].action
= NULL
;
431 irq_desc
[TIMER_IRQ
].depth
= 1;
432 irq_desc
[TIMER_IRQ
].chip
= &SIGVTALRM_irq_type
;
433 enable_irq(TIMER_IRQ
);
434 for (i
= 1; i
< NR_IRQS
; i
++) {
435 irq_desc
[i
].status
= IRQ_DISABLED
;
436 irq_desc
[i
].action
= NULL
;
437 irq_desc
[i
].depth
= 1;
438 irq_desc
[i
].chip
= &normal_irq_type
;
443 int init_aio_irq(int irq
, char *name
, irq_handler_t handler
)
447 err
= os_pipe(fds
, 1, 1);
449 printk("init_aio_irq - os_pipe failed, err = %d\n", -err
);
453 err
= um_request_irq(irq
, fds
[0], IRQ_READ
, handler
,
454 IRQF_DISABLED
| IRQF_SAMPLE_RANDOM
, name
,
455 (void *) (long) fds
[0]);
457 printk("init_aio_irq - : um_request_irq failed, err = %d\n",
466 os_close_file(fds
[0]);
467 os_close_file(fds
[1]);
473 * IRQ stack entry and exit:
475 * Unlike i386, UML doesn't receive IRQs on the normal kernel stack
476 * and switch over to the IRQ stack after some preparation. We use
477 * sigaltstack to receive signals on a separate stack from the start.
478 * These two functions make sure the rest of the kernel won't be too
479 * upset by being on a different stack. The IRQ stack has a
480 * thread_info structure at the bottom so that current et al continue
483 * to_irq_stack copies the current task's thread_info to the IRQ stack
484 * thread_info and sets the tasks's stack to point to the IRQ stack.
486 * from_irq_stack copies the thread_info struct back (flags may have
487 * been modified) and resets the task's stack pointer.
491 * What happens when two signals race each other? UML doesn't block
492 * signals with sigprocmask, SA_DEFER, or sa_mask, so a second signal
493 * could arrive while a previous one is still setting up the
496 * There are three cases -
497 * The first interrupt on the stack - sets up the thread_info and
498 * handles the interrupt
499 * A nested interrupt interrupting the copying of the thread_info -
500 * can't handle the interrupt, as the stack is in an unknown state
501 * A nested interrupt not interrupting the copying of the
502 * thread_info - doesn't do any setup, just handles the interrupt
504 * The first job is to figure out whether we interrupted stack setup.
505 * This is done by xchging the signal mask with thread_info->pending.
506 * If the value that comes back is zero, then there is no setup in
507 * progress, and the interrupt can be handled. If the value is
508 * non-zero, then there is stack setup in progress. In order to have
509 * the interrupt handled, we leave our signal in the mask, and it will
510 * be handled by the upper handler after it has set up the stack.
512 * Next is to figure out whether we are the outer handler or a nested
513 * one. As part of setting up the stack, thread_info->real_thread is
514 * set to non-NULL (and is reset to NULL on exit). This is the
515 * nesting indicator. If it is non-NULL, then the stack is already
516 * set up and the handler can run.
519 static unsigned long pending_mask
;
521 unsigned long to_irq_stack(int sig
, unsigned long *mask_out
)
523 struct thread_info
*ti
;
524 unsigned long mask
, old
;
527 mask
= xchg(&pending_mask
, 1 << sig
);
529 /* If any interrupts come in at this point, we want to
530 * make sure that their bits aren't lost by our
531 * putting our bit in. So, this loop accumulates bits
532 * until xchg returns the same value that we put in.
533 * When that happens, there were no new interrupts,
534 * and pending_mask contains a bit for each interrupt
540 mask
= xchg(&pending_mask
, old
);
541 } while(mask
!= old
);
545 ti
= current_thread_info();
546 nested
= (ti
->real_thread
!= NULL
);
548 struct task_struct
*task
;
549 struct thread_info
*tti
;
551 task
= cpu_tasks
[ti
->cpu
].task
;
552 tti
= task_thread_info(task
);
554 ti
->real_thread
= tti
;
558 mask
= xchg(&pending_mask
, 0);
559 *mask_out
|= mask
| nested
;
563 unsigned long from_irq_stack(int nested
)
565 struct thread_info
*ti
, *to
;
568 ti
= current_thread_info();
572 to
= ti
->real_thread
;
574 ti
->real_thread
= NULL
;
577 mask
= xchg(&pending_mask
, 0);