instance numbers, encoded and decoded using macros in <minix/endpoint.h>. proc number -> endpoint migration . proc_nr in the interrupt hook is now an endpoint, proc_nr_e. . m_source for messages and notifies is now an endpoint, instead of proc number. . isokendpt() converts an endpoint to a process number, returns success (but fails if the process number is out of range, the process slot is not a living process, or the given endpoint number does not match the endpoint number in the process slot, indicating an old process). . okendpt() is the same as isokendpt(), but panic()s if the conversion fails. This is mainly used for decoding message.m_source endpoints, and other endpoint numbers in kernel data structures, which should always be correct. . if DEBUG_ENABLE_IPC_WARNINGS is enabled, isokendpt() and okendpt() get passed the __FILE__ and __LINE__ of the calling lines, and print messages about what is wrong with the endpoint number (out of range proc, empty proc, or inconsistent endpoint number), with the caller, making finding where the conversion failed easy without having to include code for every call to print where things went wrong. Sometimes this is harmless (wrong arg to a kernel call), sometimes it's a fatal internal inconsistency (bogus m_source). . some process table fields have been appended an _e to indicate it's become and endpoint. . process endpoint is stored in p_endpoint, without generation number. it turns out the kernel never needs the generation number, except when fork()ing, so it's decoded then. . kernel calls all take endpoints as arguments, not proc numbers. the one exception is sys_fork(), which needs to know in which slot to put the child.
167 lines
5.2 KiB
C
167 lines
5.2 KiB
C
/* The kernel call implemented in this file:
|
|
* m_type: SYS_IRQCTL
|
|
*
|
|
* The parameters for this kernel call are:
|
|
* m5_c1: IRQ_REQUEST (control operation to perform)
|
|
* m5_c2: IRQ_VECTOR (irq line that must be controlled)
|
|
* m5_i1: IRQ_POLICY (irq policy allows reenabling interrupts)
|
|
* m5_l3: IRQ_HOOK_ID (provides index to be returned on interrupt)
|
|
* ,, ,, (returns index of irq hook assigned at kernel)
|
|
*/
|
|
|
|
#include "../system.h"
|
|
|
|
#include <minix/endpoint.h>
|
|
|
|
#if USE_IRQCTL
|
|
|
|
FORWARD _PROTOTYPE(int generic_handler, (irq_hook_t *hook));
|
|
|
|
/*===========================================================================*
|
|
* do_irqctl *
|
|
*===========================================================================*/
|
|
PUBLIC int do_irqctl(m_ptr)
|
|
register message *m_ptr; /* pointer to request message */
|
|
{
|
|
/* Dismember the request message. */
|
|
int irq_vec;
|
|
int irq_hook_id;
|
|
int notify_id;
|
|
int r = OK;
|
|
int i;
|
|
irq_hook_t *hook_ptr;
|
|
struct proc *rp;
|
|
struct priv *privp;
|
|
|
|
/* Hook identifiers start at 1 and end at NR_IRQ_HOOKS. */
|
|
irq_hook_id = (unsigned) m_ptr->IRQ_HOOK_ID - 1;
|
|
irq_vec = (unsigned) m_ptr->IRQ_VECTOR;
|
|
|
|
/* See what is requested and take needed actions. */
|
|
switch(m_ptr->IRQ_REQUEST) {
|
|
|
|
/* Enable or disable IRQs. This is straightforward. */
|
|
case IRQ_ENABLE:
|
|
case IRQ_DISABLE:
|
|
if (irq_hook_id >= NR_IRQ_HOOKS || irq_hook_id < 0 ||
|
|
irq_hooks[irq_hook_id].proc_nr_e == NONE) return(EINVAL);
|
|
if (irq_hooks[irq_hook_id].proc_nr_e != m_ptr->m_source) return(EPERM);
|
|
if (m_ptr->IRQ_REQUEST == IRQ_ENABLE)
|
|
enable_irq(&irq_hooks[irq_hook_id]);
|
|
else
|
|
disable_irq(&irq_hooks[irq_hook_id]);
|
|
break;
|
|
|
|
/* Control IRQ policies. Set a policy and needed details in the IRQ table.
|
|
* This policy is used by a generic function to handle hardware interrupts.
|
|
*/
|
|
case IRQ_SETPOLICY:
|
|
|
|
/* Check if IRQ line is acceptable. */
|
|
if (irq_vec < 0 || irq_vec >= NR_IRQ_VECTORS) return(EINVAL);
|
|
|
|
rp= proc_addr(who_p);
|
|
privp= priv(rp);
|
|
if (!privp)
|
|
{
|
|
kprintf("no priv structure!\n");
|
|
return EPERM;
|
|
}
|
|
if (privp->s_flags & CHECK_IRQ)
|
|
{
|
|
for (i= 0; i<privp->s_nr_irq; i++)
|
|
{
|
|
if (irq_vec == privp->s_irq_tab[i])
|
|
break;
|
|
}
|
|
if (i >= privp->s_nr_irq)
|
|
{
|
|
kprintf(
|
|
"do_irqctl: IRQ check failed for proc %d, IRQ %d\n",
|
|
m_ptr->m_source, irq_vec);
|
|
return EPERM;
|
|
}
|
|
}
|
|
|
|
/* Find a free IRQ hook for this mapping. */
|
|
hook_ptr = NULL;
|
|
for (irq_hook_id=0; irq_hook_id<NR_IRQ_HOOKS; irq_hook_id++) {
|
|
if (irq_hooks[irq_hook_id].proc_nr_e == NONE) {
|
|
hook_ptr = &irq_hooks[irq_hook_id]; /* free hook */
|
|
break;
|
|
}
|
|
}
|
|
if (hook_ptr == NULL) return(ENOSPC);
|
|
|
|
/* When setting a policy, the caller must provide an identifier that
|
|
* is returned on the notification message if a interrupt occurs.
|
|
*/
|
|
notify_id = (unsigned) m_ptr->IRQ_HOOK_ID;
|
|
if (notify_id > CHAR_BIT * sizeof(irq_id_t) - 1) return(EINVAL);
|
|
|
|
/* Install the handler. */
|
|
hook_ptr->proc_nr_e = m_ptr->m_source; /* process to notify */
|
|
hook_ptr->notify_id = notify_id; /* identifier to pass */
|
|
hook_ptr->policy = m_ptr->IRQ_POLICY; /* policy for interrupts */
|
|
put_irq_handler(hook_ptr, irq_vec, generic_handler);
|
|
|
|
/* Return index of the IRQ hook in use. */
|
|
m_ptr->IRQ_HOOK_ID = irq_hook_id + 1;
|
|
break;
|
|
|
|
case IRQ_RMPOLICY:
|
|
if (irq_hook_id < 0 || irq_hook_id >= NR_IRQ_HOOKS ||
|
|
irq_hooks[irq_hook_id].proc_nr_e == NONE) {
|
|
return(EINVAL);
|
|
} else if (m_ptr->m_source != irq_hooks[irq_hook_id].proc_nr_e) {
|
|
return(EPERM);
|
|
}
|
|
/* Remove the handler and return. */
|
|
rm_irq_handler(&irq_hooks[irq_hook_id]);
|
|
break;
|
|
|
|
default:
|
|
r = EINVAL; /* invalid IRQ_REQUEST */
|
|
}
|
|
return(r);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* generic_handler *
|
|
*===========================================================================*/
|
|
PRIVATE int generic_handler(hook)
|
|
irq_hook_t *hook;
|
|
{
|
|
/* This function handles hardware interrupt in a simple and generic way. All
|
|
* interrupts are transformed into messages to a driver. The IRQ line will be
|
|
* reenabled if the policy says so.
|
|
*/
|
|
int proc;
|
|
|
|
/* As a side-effect, the interrupt handler gathers random information by
|
|
* timestamping the interrupt events. This is used for /dev/random.
|
|
*/
|
|
get_randomness(hook->irq);
|
|
|
|
/* Check if the handler is still alive. If not, forget about the
|
|
* interrupt. This should never happen, as processes that die
|
|
* automatically get their interrupt hooks unhooked.
|
|
*/
|
|
if(!isokendpt(hook->proc_nr_e, &proc)) {
|
|
hook->proc_nr_e = NONE;
|
|
return 0;
|
|
}
|
|
|
|
/* Add a bit for this interrupt to the process' pending interrupts. When
|
|
* sending the notification message, this bit map will be magically set
|
|
* as an argument.
|
|
*/
|
|
priv(proc_addr(proc))->s_int_pending |= (1 << hook->notify_id);
|
|
|
|
/* Build notification message and return. */
|
|
lock_notify(HARDWARE, hook->proc_nr_e);
|
|
return(hook->policy & IRQ_REENABLE);
|
|
}
|
|
|
|
#endif /* USE_IRQCTL */
|
|
|