2 * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
3 * Licensed under the GPL
12 #include <sys/types.h>
14 #include "user_util.h"
15 #include "kern_util.h"
18 #include "signal_user.h"
34 static struct irq_fd
*active_fds
= NULL
;
35 static struct irq_fd
**last_irq_ptr
= &active_fds
;
37 static struct pollfd
*pollfds
= NULL
;
38 static int pollfds_num
= 0;
39 static int pollfds_size
= 0;
41 extern int io_count
, intr_count
;
43 extern void free_irqs(void);
45 void sigio_handler(int sig
, union uml_pt_regs
*regs
)
47 struct irq_fd
*irq_fd
;
50 if(smp_sigio_handler()) return;
52 n
= poll(pollfds
, pollfds_num
, 0);
54 if(errno
== EINTR
) continue;
55 printk("sigio_handler : poll returned %d, "
56 "errno = %d\n", n
, errno
);
62 for(i
= 0; i
< pollfds_num
; i
++){
63 if(pollfds
[i
].revents
!= 0){
64 irq_fd
->current_events
= pollfds
[i
].revents
;
67 irq_fd
= irq_fd
->next
;
70 for(irq_fd
= active_fds
; irq_fd
!= NULL
; irq_fd
= irq_fd
->next
){
71 if(irq_fd
->current_events
!= 0){
72 irq_fd
->current_events
= 0;
73 do_IRQ(irq_fd
->irq
, regs
);
81 int activate_ipi(int fd
, int pid
)
83 return(os_set_fd_async(fd
, pid
));
86 static void maybe_sigio_broken(int fd
, int type
)
89 if((type
== IRQ_WRITE
) && !pty_output_sigio
){
90 write_sigio_workaround();
93 else if((type
== IRQ_READ
) && !pty_close_sigio
){
94 write_sigio_workaround();
100 int activate_fd(int irq
, int fd
, int type
, void *dev_id
)
102 struct pollfd
*tmp_pfd
;
103 struct irq_fd
*new_fd
, *irq_fd
;
105 int pid
, events
, err
, n
, size
;
108 err
= os_set_fd_async(fd
, pid
);
112 new_fd
= um_kmalloc(sizeof(*new_fd
));
117 if(type
== IRQ_READ
) events
= POLLIN
| POLLPRI
;
118 else events
= POLLOUT
;
119 *new_fd
= ((struct irq_fd
) { .next
= NULL
,
126 .current_events
= 0 } );
128 /* Critical section - locked by a spinlock because this stuff can
129 * be changed from interrupt handlers. The stuff above is done
130 * outside the lock because it allocates memory.
133 /* Actually, it only looks like it can be called from interrupt
134 * context. The culprit is reactivate_fd, which calls
135 * maybe_sigio_broken, which calls write_sigio_workaround,
136 * which calls activate_fd. However, write_sigio_workaround should
137 * only be called once, at boot time. That would make it clear that
138 * this is called only from process context, and can be locked with
142 for(irq_fd
= active_fds
; irq_fd
!= NULL
; irq_fd
= irq_fd
->next
){
143 if((irq_fd
->fd
== fd
) && (irq_fd
->type
== type
)){
144 printk("Registering fd %d twice\n", fd
);
145 printk("Irqs : %d, %d\n", irq_fd
->irq
, irq
);
146 printk("Ids : 0x%x, 0x%x\n", irq_fd
->id
, dev_id
);
152 if(n
== pollfds_size
){
154 /* Here we have to drop the lock in order to call
155 * kmalloc, which might sleep. If something else
156 * came in and changed the pollfds array, we free
157 * the buffer and try again.
160 size
= (pollfds_num
+ 1) * sizeof(pollfds
[0]);
161 tmp_pfd
= um_kmalloc(size
);
165 if(n
== pollfds_size
)
170 memcpy(tmp_pfd
, pollfds
,
171 sizeof(pollfds
[0]) * pollfds_size
);
178 if(type
== IRQ_WRITE
)
181 pollfds
[pollfds_num
] = ((struct pollfd
) { .fd
= fd
,
186 *last_irq_ptr
= new_fd
;
187 last_irq_ptr
= &new_fd
->next
;
191 /* This calls activate_fd, so it has to be outside the critical
194 maybe_sigio_broken(fd
, type
);
205 static void free_irq_by_cb(int (*test
)(struct irq_fd
*, void *), void *arg
)
207 struct irq_fd
**prev
;
213 while(*prev
!= NULL
){
214 if((*test
)(*prev
, arg
)){
215 struct irq_fd
*old_fd
= *prev
;
216 if((pollfds
[i
].fd
!= -1) &&
217 (pollfds
[i
].fd
!= (*prev
)->fd
)){
218 printk("free_irq_by_cb - mismatch between "
219 "active_fds and pollfds, fd %d vs %d\n",
220 (*prev
)->fd
, pollfds
[i
].fd
);
226 /* This moves the *whole* array after pollfds[i] (though
227 * it doesn't spot as such)! */
229 memmove(&pollfds
[i
], &pollfds
[i
+ 1],
230 (pollfds_num
- i
) * sizeof(pollfds
[0]));
232 if(last_irq_ptr
== &old_fd
->next
)
234 *prev
= (*prev
)->next
;
235 if(old_fd
->type
== IRQ_WRITE
)
236 ignore_sigio_fd(old_fd
->fd
);
240 prev
= &(*prev
)->next
;
252 static int same_irq_and_dev(struct irq_fd
*irq
, void *d
)
254 struct irq_and_dev
*data
= d
;
256 return((irq
->irq
== data
->irq
) && (irq
->id
== data
->dev
));
259 void free_irq_by_irq_and_dev(unsigned int irq
, void *dev
)
261 struct irq_and_dev data
= ((struct irq_and_dev
) { .irq
= irq
,
264 free_irq_by_cb(same_irq_and_dev
, &data
);
267 static int same_fd(struct irq_fd
*irq
, void *fd
)
269 return(irq
->fd
== *((int *) fd
));
272 void free_irq_by_fd(int fd
)
274 free_irq_by_cb(same_fd
, &fd
);
277 static struct irq_fd
*find_irq_by_fd(int fd
, int irqnum
, int *index_out
)
282 for(irq
=active_fds
; irq
!= NULL
; irq
= irq
->next
){
283 if((irq
->fd
== fd
) && (irq
->irq
== irqnum
)) break;
287 printk("find_irq_by_fd doesn't have descriptor %d\n", fd
);
290 if((pollfds
[i
].fd
!= -1) && (pollfds
[i
].fd
!= fd
)){
291 printk("find_irq_by_fd - mismatch between active_fds and "
292 "pollfds, fd %d vs %d, need %d\n", irq
->fd
,
302 void reactivate_fd(int fd
, int irqnum
)
309 irq
= find_irq_by_fd(fd
, irqnum
, &i
);
315 pollfds
[i
].fd
= irq
->fd
;
319 /* This calls activate_fd, so it has to be outside the critical
322 maybe_sigio_broken(fd
, irq
->type
);
325 void deactivate_fd(int fd
, int irqnum
)
332 irq
= find_irq_by_fd(fd
, irqnum
, &i
);
340 int deactivate_all_fds(void)
345 for(irq
=active_fds
;irq
!= NULL
;irq
= irq
->next
){
346 err
= os_clear_fd_async(irq
->fd
);
350 /* If there is a signal already queued, after unblocking ignore it */
351 set_handler(SIGIO
, SIG_IGN
, 0, -1);
356 void forward_ipi(int fd
, int pid
)
360 err
= os_set_owner(fd
, pid
);
362 printk("forward_ipi: set_owner failed, fd = %d, me = %d, "
363 "target = %d, err = %d\n", fd
, os_getpid(), pid
, -err
);
366 void forward_interrupts(int pid
)
373 for(irq
=active_fds
;irq
!= NULL
;irq
= irq
->next
){
374 err
= os_set_owner(irq
->fd
, pid
);
376 /* XXX Just remove the irq rather than
377 * print out an infinite stream of these
379 printk("Failed to forward %d to pid %d, err = %d\n",
388 void init_irq_signals(int on_sigstack
)
393 flags
= on_sigstack
? SA_ONSTACK
: 0;
394 if(timer_irq_inited
) h
= (__sighandler_t
) alarm_handler
;
395 else h
= boot_timer_handler
;
397 set_handler(SIGVTALRM
, h
, flags
| SA_RESTART
,
398 SIGUSR1
, SIGIO
, SIGWINCH
, SIGALRM
, -1);
399 set_handler(SIGIO
, (__sighandler_t
) sig_handler
, flags
| SA_RESTART
,
400 SIGUSR1
, SIGIO
, SIGWINCH
, SIGALRM
, SIGVTALRM
, -1);
401 signal(SIGWINCH
, SIG_IGN
);
405 * Overrides for Emacs so that we follow Linus's tabbing style.
406 * Emacs will notice this stuff at the end of the file and automatically
407 * adjust the settings for this buffer only. This must remain at the end
409 * ---------------------------------------------------------------------------
411 * c-file-style: "linux"