static int __exit ge_counter_remove(struct platform_device *pdev)
{
struct driver_data *data = platform_get_drvdata(pdev);
int i;
for (i = 0; i < data->num_counter; i++)
delete_counter(&data->vdata[i]);
kobject_put(data->dir);
kfree(data);
return 0;
}
int memcache_delete (struct connection *c, const char *key, int key_len) {
const int dog_len = get_at_prefix_length (key, key_len);
key += dog_len;
key_len -= dog_len;
int counter_id;
if (sscanf (key, "counter%d", &counter_id) >= 1) {
delete_counter (counter_id, 0);
write_out (&c->Out, "DELETED\r\n", 9);
return 0;
}
return not_found (c);
}
int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
traffic db;
db.counter = create_counter();
db.fdb = create_fdb();
add_periodic_event_callback( 10, show_counter, &db );
set_packet_in_handler( handle_packet_in, &db );
set_flow_removed_handler( handle_flow_removed, &db );
start_trema();
delete_fdb( db.fdb );
delete_counter( db.counter );
return 0;
}
int mutate_genome(GENOME *genome, double m_replacement, double m_insertion, double m_deletion, double m_duplication, double m_factor)
{
long j, p, gene_no, num_genes;
unsigned long gene_startpos, gpos, target_pos, gene_length;
unsigned char flipmask;
double mf = 1.0;
if (m_factor && genome->mut_flag)
{
errno = 0;
mf = pow(m_factor, genome->mut_flag);
if (errno)
{
fprintf(stderr, "mutate_genome: error in pow(%f, %ld): ", m_factor, genome->mut_flag);
perror("");
}
else
{
m_replacement *= mf;
m_insertion *= mf;
m_deletion *= mf;
m_duplication *= mf;
if (m_replacement > 1.0)
m_replacement = 1.0;
if (m_insertion > 1.0)
m_insertion = 1.0;
if (m_deletion > 1.0)
m_deletion = 1.0;
if (m_duplication > 1.0)
m_duplication = 1.0;
}
}
#ifdef MEMDEBUG
verify_Watchdogs();
#endif
genome->num_mutations++;
if (m_replacement > 0.0)
{
p = next_mutpos(m_replacement, 0);
while (p < genome->length)
{
gene_no = l4_gene_number(genome, p);
flipmask = 1 << lnd_random(8);
genome->g[p] ^= flipmask;
if (l4_promotermask(flipmask))
{
if (l4_promoter(genome->g[p]))
{
if (resize_genome(genome, genome->length, genome->num_genes + 1) < 0)
do_error("Error resizing genome while creating new promoter");
else
insert_counter(genome, gene_no);
#ifdef MEMDEBUG
verify_Watchdogs();
#endif
}
else
{
delete_counter(genome, gene_no);
#ifdef MEMDEBUG
verify_Watchdogs();
#endif
if (resize_genome(genome, genome->length, genome->num_genes - 1) < 0)
do_error("Error resizing genome while destroying promoter");
}
}
else if (gene_no != ULONG_MAX)
{
if (genome->flags & GNM_USG)
genome->usg_count[gene_no] = 0;
if (genome->flags & GNM_BP)
genome->bp_count[gene_no] = 0;
}
p = next_mutpos(m_replacement, p) + 1;
}
}
#ifdef MUTATE_CONSITENCY
if (l4_num_genes(genome) != genome->num_genes)
fprintf(stderr, "Inconsistent genome after replacement\n");
#endif
#ifdef MEMDEBUG
verify_Watchdogs();
#endif
if (m_insertion > 0.0)
{
p = next_mutpos(m_insertion, 0);
while (p <= genome->length)
{
gene_no = l4_gene_number(genome, p);
#ifdef MEMDEBUG
verify_Watchdogs();
#endif
if (resize_genome(genome, genome->length + 1, genome->num_genes) < 0)
{
do_error("resizing failure during insertion");
break;
}
for (j = genome->length - 1; p < j; j--)
genome->g[j] = genome->g[j - 1];
genome->g[p] = (unsigned char) lnd_random(256);
if (l4_promoter(genome->g[p]))
{
if (resize_genome(genome, genome->length, genome->num_genes + 1) < 0)
{
do_error("resizing failure during insertion of counter");
break;
}
insert_counter(genome, gene_no);
}
#ifdef MEMDEBUG
verify_Watchdogs();
#endif
p = next_mutpos(m_insertion, p) + 2;
}
}
#ifdef MUTATE_CONSITENCY
if (l4_num_genes(genome) != genome->num_genes)
fprintf(stderr, "Inconsistent genome after inesertion\n");
#endif
/* printf(" deleting at random, length = %lu\n", genome->length); */
#ifdef MEMDEBUG
verify_Watchdogs();
#endif
if ((genome->length > 0) && (m_deletion > 0.0))
{
p = next_mutpos(m_deletion, 0);
while ((genome->length > 0) && (p < (genome->length - 1)))
{
gene_no = l4_gene_number(genome, p);
if (l4_promoter(genome->g[p]))
{
delete_counter(genome, gene_no);
if (resize_genome(genome, genome->length, genome->num_genes - 1) < 0)
do_error("resizing failure during deletion of counter");
}
for (j = p + 1; j < genome->length; j++)
genome->g[j - 1] = genome->g[j];
if (resize_genome(genome, genome->length - 1, genome->num_genes))
{
do_error("resizing failure during deletion");
break;
}
p = next_mutpos(m_deletion, p);
}
}
#ifdef MUTATE_CONSITENCY
if (l4_num_genes(genome) != genome->num_genes)
fprintf(stderr, "Inconsistent genome after deletion\n");
#endif
#ifdef MEMDEBUG
verify_Watchdogs();
#endif
if (m_duplication > 0.0)
{
num_genes = genome->num_genes;
p = next_mutpos(m_duplication, 0);
while (p < num_genes)
{
gene_startpos = l4_gene_startposition(genome, p);
if (gene_startpos == ULONG_MAX)
{
do_error("failed to map gene to character position during gene duplication");
break;
}
if (gene_startpos == genome->length - 1)
gpos = gene_startpos;
else
{
gpos = gene_startpos + 1;
while ((gpos < genome->length) && !l4_terminator(genome->g[gpos]) && !l4_promoter(genome->g[gpos]))
gpos++;
if (gpos == genome->length)
gpos--;
if (l4_promoter(genome->g[gpos]))
gpos--;
}
gene_length = gpos - gene_startpos + 1;
target_pos = genome->length;
if (resize_genome(genome, genome->length + gene_length, genome->num_genes + 1))
{
do_error("resizing failure during gene duplication");
break;
}
for (j = 0; j < gene_length; j++)
genome->g[target_pos + j] = genome->g[gene_startpos + j];
insert_counter(genome, genome->num_genes - 1);
p = next_mutpos(m_duplication, p) + 1;
}
}
#ifdef MUTATE_CONSITENCY
if (l4_num_genes(genome) != genome->num_genes)
fprintf(stderr, "Inconsistent genome after duplication\n");
#endif
#ifdef MEMDEBUG
verify_Watchdogs();
#endif
return (0);
}
static int ge_counter_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct ge_counter_platform_data *pdata = dev_get_platdata(dev);
struct driver_data *data;
struct counter_data *dest;
unsigned int irq;
int i, ret;
if (!pdata) {
pdata = ge_counter_get_devtree_pdata(dev);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
}
data = kzalloc(sizeof(struct driver_data) + sizeof(struct counter_data)
* pdata->num_counter, GFP_KERNEL);
if (!data)
return -ENOMEM;
data->dir = kobject_create_and_add("counter", &pdev->dev.kobj);
if (!data->dir) {
dev_err(&pdev->dev, "Cannot create sysfs counter dir 'counter'\n");
kfree(data);
return -EIO;
}
data->num_counter = pdata->num_counter;
for (i = 0; i < pdata->num_counter; i++) {
struct ge_counter *src = &pdata->counter[i];
dest = &data->vdata[i];
if (!src->name) {
dev_err(&pdev->dev, "Counter name must be set\n");
ret = -EINVAL;
goto err;
}
if (!src->gpio || gpio_request(src->gpio, src->name)) {
dev_err(&pdev->dev, "Invalid counter GPIO %d\n", src->gpio);
ret = -EINVAL;
goto err;
}
gpio_direction_input(src->gpio);
irq = gpio_to_irq(src->gpio);
enable_irq_wake(irq);
ret = request_any_context_irq(irq, counter_event, src->irq_type,
"ge_counter", dest);
if (ret < 0) {
dev_err(&pdev->dev, "Cannot request IRQ %u for GPIO %u", irq, src->gpio);
ret = -EINVAL;
goto err_gpio;
}
dest->subdir = kobject_create_and_add(src->name, data->dir);
if (!dest->subdir) {
dev_err(&pdev->dev, "Cannot create sysfs counter dir '%s'\n",
src->name);
ret = -EIO;
goto err_irq;
}
spin_lock_init(&dest->lock);
dest->gpio = src->gpio;
dest->interval = msecs_to_jiffies(src->interval);
dest->counter = 0UL;
dest->start_jiffies = jiffies;
dest->start_count = 0UL;
dest->reset_on_read = src->reset_on_read;
dest->use_timer = false;
dest->interval_count_valid = false;
dest->counter_attr.show = counter_show;
dest->counter_attr.store = counter_store;
sysfs_attr_init(&dest->counter_attr.attr);
dest->counter_attr.attr.name = "counter";
dest->counter_attr.attr.mode = S_IRUGO | S_IWUSR;
ret = sysfs_create_file(dest->subdir, &dest->counter_attr.attr);
if (ret)
goto err_dir;
dest->elapsed_attr.show = elapsed_show;
dest->elapsed_attr.store = elapsed_store;
sysfs_attr_init(&dest->elapsed_attr.attr);
dest->elapsed_attr.attr.name = "elapsed";
dest->elapsed_attr.attr.mode = S_IRUGO | S_IWUSR;
ret = sysfs_create_file(dest->subdir, &dest->elapsed_attr.attr);
if (ret)
goto err_file1;
dest->state_attr.show = state_show;
sysfs_attr_init(&dest->state_attr.attr);
dest->state_attr.attr.name = "state";
dest->state_attr.attr.mode = S_IRUGO;
ret = sysfs_create_file(dest->subdir, &dest->state_attr.attr);
if (ret)
goto err_file2;
dest->reset_on_read_attr.show = reset_on_read_show;
dest->reset_on_read_attr.store = reset_on_read_store;
sysfs_attr_init(&dest->reset_on_read_attr.attr);
dest->reset_on_read_attr.attr.name = "reset_on_read";
dest->reset_on_read_attr.attr.mode = S_IRUGO | S_IWUSR;
ret = sysfs_create_file(dest->subdir, &dest->reset_on_read_attr.attr);
if (ret)
goto err_file3;
if (src->interval) {
dest->interval_attr.show = interval_show;
dest->interval_attr.store = interval_store;
sysfs_attr_init(&dest->interval_attr.attr);
dest->interval_attr.attr.name = "interval";
dest->interval_attr.attr.mode = S_IRUGO | S_IWUSR;
ret = sysfs_create_file(dest->subdir, &dest->interval_attr.attr);
if (ret)
goto err_file4;
dest->interval_count_attr.show = interval_count_show;
sysfs_attr_init(&dest->interval_count_attr.attr);
dest->interval_count_attr.attr.name = "interval_count";
dest->interval_count_attr.attr.mode = S_IRUGO;
ret = sysfs_create_file(dest->subdir, &dest->interval_count_attr.attr);
if (ret)
goto err_file5;
dest->use_timer = true;
init_timer(&dest->timer);
dest->timer.data = (unsigned long)dest;
dest->timer.function = timeout;
dest->jiffies = jiffies;
dest->timer.expires = jiffies + dest->interval;
add_timer(&dest->timer);
}
}
platform_set_drvdata(pdev, data);
return 0;
err_file5:
sysfs_remove_file(dest->subdir, &dest->interval_attr.attr);
err_file4:
sysfs_remove_file(dest->subdir, &dest->reset_on_read_attr.attr);
err_file3:
sysfs_remove_file(dest->subdir, &dest->state_attr.attr);
err_file2:
sysfs_remove_file(dest->subdir, &dest->elapsed_attr.attr);
err_file1:
sysfs_remove_file(dest->subdir, &dest->counter_attr.attr);
err_dir:
kobject_put(dest->subdir);
err_irq:
free_irq(irq, dest);
err_gpio:
gpio_free(dest->gpio);
err:
for (--i; i >= 0; i--)
delete_counter(&data->vdata[i]);
kobject_put(data->dir);
kfree(data);
return ret;
}
