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; }