minix/drivers/fbd/rule.c
Ben Gras 2bfeeed885 drop segment from safecopy invocations
. all invocations were S or D, so can safely be dropped
	  to prepare for the segmentless world
	. still assign D to the SCP_SEG field in the message
	  to make previous kernels usable
2012-06-16 16:22:51 +00:00

184 lines
4.8 KiB
C

#include <minix/drivers.h>
#include <minix/ioctl.h>
#include <sys/ioc_fbd.h>
#include "action.h"
#include "rule.h"
static struct fbd_rule rules[MAX_RULES];
static struct fbd_rule *matches[MAX_RULES];
static int nr_matches;
/*===========================================================================*
* rule_ctl *
*===========================================================================*/
int rule_ctl(int request, endpoint_t endpt, cp_grant_id_t grant)
{
/* Handle an I/O control request regarding rules. */
fbd_rulenum_t i;
int r;
/* Note that any of the safecopy calls may fail if the ioctl is
* improperly defined in userland; never panic if they fail!
*/
switch (request) {
case FBDCADDRULE:
/* Find a free rule slot. */
for (i = 1; i <= MAX_RULES; i++)
if (rules[i-1].num == 0)
break;
if (i == MAX_RULES+1)
return ENOMEM;
/* Copy in the rule. */
if ((r = sys_safecopyfrom(endpt, grant, 0,
(vir_bytes) &rules[i-1], sizeof(rules[0]))) != OK)
return r;
/* Mark the rule as active, and return its number. */
rules[i-1].num = i;
return i;
case FBDCDELRULE:
/* Copy in the given rule number. */
if ((r = sys_safecopyfrom(endpt, grant, 0, (vir_bytes) &i,
sizeof(i))) != OK)
return r;
/* Fail if the given rule number is not valid or in use.
* Allow the caller to determine the maximum rule number.
*/
if (i <= 0 || i > MAX_RULES) return EINVAL;
if (rules[i-1].num != i) return ENOENT;
/* Mark the rule as not active. */
rules[i-1].num = 0;
return OK;
case FBDCGETRULE:
/* Copy in just the rule number from the given structure. */
if ((r = sys_safecopyfrom(endpt, grant,
offsetof(struct fbd_rule, num), (vir_bytes) &i,
sizeof(i))) != OK)
return r;
/* Fail if the given rule number is not valid or in use.
* Allow the caller to determine the maximum rule number.
*/
if (i <= 0 || i > MAX_RULES) return EINVAL;
if (rules[i-1].num != i) return ENOENT;
/* Copy out the entire rule as is. */
return sys_safecopyto(endpt, grant, 0, (vir_bytes) &rules[i-1],
sizeof(rules[0]));
default:
return EINVAL;
}
}
/*===========================================================================*
* rule_match *
*===========================================================================*/
static int rule_match(struct fbd_rule *rule, u64_t pos, size_t size, int flag)
{
/* Check whether the given rule matches the given parameters. As side
* effect, update counters in the rule as appropriate.
*/
/* Ranges must overlap (start < pos+size && end > pos). */
if (cmp64(rule->start, add64u(pos, size)) >= 0 ||
(cmp64u(rule->end, 0) && cmp64(rule->end, pos) <= 0))
return FALSE;
/* Flags must match. */
if (!(rule->flags & flag)) return FALSE;
/* This is a match, but is it supposed to trigger yet? */
if (rule->skip > 0) {
rule->skip--;
return FALSE;
}
return TRUE;
}
/*===========================================================================*
* rule_find *
*===========================================================================*/
int rule_find(u64_t pos, size_t size, int flag)
{
/* Find all matching rules, and return a hook mask. */
struct fbd_rule *rule;
int i, hooks;
nr_matches = 0;
hooks = 0;
for (i = 0; i < MAX_RULES; i++) {
rule = &rules[i];
if (rule->num == 0) continue;
if (!rule_match(rule, pos, size, flag))
continue;
matches[nr_matches++] = rule;
/* If the rule has a limited lifetime, update it now. */
if (rule->count > 0) {
rule->count--;
/* Disable the rule from future matching. */
if (rule->count == 0)
rule->num = 0;
}
hooks |= action_mask(rule);
}
return hooks;
}
/*===========================================================================*
* rule_pre_hook *
*===========================================================================*/
void rule_pre_hook(iovec_t *iov, unsigned *count, size_t *size,
u64_t *pos)
{
int i;
for (i = 0; i < nr_matches; i++)
if (action_mask(matches[i]) & PRE_HOOK)
action_pre_hook(matches[i], iov, count, size, pos);
}
/*===========================================================================*
* rule_io_hook *
*===========================================================================*/
void rule_io_hook(char *buf, size_t size, u64_t pos, int flag)
{
int i;
for (i = 0; i < nr_matches; i++)
if (action_mask(matches[i]) & IO_HOOK)
action_io_hook(matches[i], buf, size, pos, flag);
}
/*===========================================================================*
* rule_post_hook *
*===========================================================================*/
void rule_post_hook(size_t osize, int *result)
{
int i;
for (i = 0; i < nr_matches; i++)
if (action_mask(matches[i]) & POST_HOOK)
action_post_hook(matches[i], osize, result);
}