memmap_node *memmap::add_region (Elf32_Addr start_addr, Elf32_Word size) { memmap_node *aux = list, *prior = NULL; if (start_addr + ((unsigned)size) > memsize) { fprintf(stderr, "ArchC memory manager error: not enough memory in target.\n"); fprintf(stderr, " add_region failed: Start address = 0x%X ; Size = 0x%X", start_addr, size); fprintf(stderr, " ; Total Mem Size = 0x%X\n", memsize); exit(EXIT_FAILURE); } while (aux != NULL && aux->get_addr() < start_addr) { prior = aux; aux = aux->get_next(); } if (prior == NULL) { prior = aux; aux = aux->get_next(); } prior->set_next(new memmap_node(new memmap_node(aux, MS_FREE, start_addr+size), MS_USED, start_addr)); fix_consistency(); return find_region(start_addr); }
void iovmm_unmap_oto(struct device *dev, phys_addr_t phys) { struct exynos_vm_region *region; struct exynos_iovmm *vmm = exynos_get_iovmm(dev); size_t unmapped_size; /* This function must not be called in IRQ handlers */ BUG_ON(in_irq()); if (WARN_ON(phys & ~PAGE_MASK)) phys = round_down(phys, PAGE_SIZE); spin_lock(&vmm->lock); region = find_region(vmm, (dma_addr_t)phys); if (WARN_ON(!region)) { spin_unlock(&vmm->lock); return; } list_del(®ion->node); spin_unlock(&vmm->lock); unmapped_size = iommu_unmap(vmm->domain, region->start, region->size); exynos_sysmmu_tlb_invalidate(dev); WARN_ON(unmapped_size != region->size); dev_dbg(dev, "IOVMM: Unmapped %#x bytes from %#x.\n", unmapped_size, region->start); kfree(region); }
/** * Unregister MMIO region from a cell. * @param cell Cell the region belongs to. * @param start Region start address as it was passed to * mmio_region_register(). * * @see mmio_region_register */ void mmio_region_unregister(struct cell *cell, unsigned long start) { int index; spin_lock(&cell->mmio_region_lock); index = find_region(cell, start, 1, NULL, NULL); if (index >= 0) { /* * Advance the generation to odd value, indicating that * modifications are ongoing. Commit this change via a barrier * so that other CPUs will see it before we start. */ cell->mmio_generation++; memory_barrier(); for (/* empty */; index < cell->num_mmio_regions; index++) copy_region(cell, index + 1, index); cell->num_mmio_regions--; /* * Ensure all regions and their number are committed before * advancing the generation. */ memory_barrier(); cell->mmio_generation++; } spin_unlock(&cell->mmio_region_lock); }
void atari_stram_free( void *addr ) { BLOCK *block; DPRINTK( "atari_stram_free(addr=%p)\n", addr ); if (!(block = find_region( addr ))) { printk( KERN_ERR "Attempt to free non-allocated ST-RAM block at %p " "from %p\n", addr, __builtin_return_address(0) ); return; } DPRINTK( "atari_stram_free: found block (%p): size=%08lx, owner=%s, " "flags=%02x\n", block, block->size, block->owner, block->flags ); if (!(block->flags & BLOCK_GFP)) goto fail; DPRINTK("atari_stram_free: is kmalloced, order_size=%d\n", get_order(block->size)); free_pages((unsigned long)addr, get_order(block->size)); remove_region( block ); return; fail: printk( KERN_ERR "atari_stram_free: cannot free block at %p " "(called from %p)\n", addr, __builtin_return_address(0) ); }
int find_region (int ** matrix, int col, int row) { if (col >= DIMENSIONS || row >= DIMENSIONS || row < 0 || col < 0) return 0; int total; if (matrix[col][row] != 1) { return 0; // we aren't part of the area. } else { // mark ourselves as seen matrix[col][row] = 2; total = 1; // Count ourselves // Up? total += find_region (matrix, col, row + 1); // Down? total += find_region (matrix, col, row - 1); // Left? total += find_region (matrix, col - 1, row); // Right? total += find_region (matrix, col + 1, row); } return total; }
/** * Dispatch MMIO access of a cell CPU. * @param mmio MMIO access description. @a mmio->value will receive the * result of a successful read access. All @a mmio fields * may have been modified on return. * * @return MMIO_HANDLED on success, MMIO_UNHANDLED if no region is registered * for the access address and size, or MMIO_ERROR if an access error was * detected. * * @see mmio_region_register * @see mmio_region_unregister */ enum mmio_result mmio_handle_access(struct mmio_access *mmio) { struct mmio_region_handler handler; unsigned long region_base; if (find_region(this_cell(), mmio->address, mmio->size, ®ion_base, &handler) < 0) return MMIO_UNHANDLED; mmio->address -= region_base; return handler.function(handler.arg, mmio); }
/** * Dispatch MMIO access of a cell CPU. * @param mmio MMIO access description. @a mmio->value will receive the * result of a successful read access. All @a mmio fields * may have been modified on return. * * @return MMIO_HANDLED on success, MMIO_UNHANDLED if no region is registered * for the access address and size, or MMIO_ERROR if an access error was * detected. * * @see mmio_region_register * @see mmio_region_unregister */ enum mmio_result mmio_handle_access(struct mmio_access *mmio) { struct cell *cell = this_cell(); int index = find_region(cell, mmio->address, mmio->size); mmio_handler handler; if (index < 0) return MMIO_UNHANDLED; handler = cell->mmio_handlers[index].handler; mmio->address -= cell->mmio_locations[index].start; return handler(cell->mmio_handlers[index].arg, mmio); }
errval_t debug_dump_region(struct debug_q* que, regionid_t rid) { errval_t err; // find region struct memory_list* region = NULL; err = find_region(que, ®ion, rid); if (err_is_fail(err)){ return err; } dump_list(region); return SYS_ERR_OK; }
bool AbsScarRegionDetector::test_point(float * d){ int id = find_region(d); // find the closest scoring info. //printf("test: %f grp:%d score:%f\n", d[0], id, score); //printf("score: %f\n", score); if(!this->is_valid(d) || id < 0){ this->update_test_regions(-1,d,false); return false; } else{ this->update_test_regions(id,d,true); return true; } }
array_list_t *region_filter(array_list_t *input_records, array_list_t *failed, variant_stats_t **input_stats, char *filter_name, void *f_args) { assert(input_records); assert(failed); array_list_t *passed = array_list_new(input_records->size + 1, 1, COLLECTION_MODE_ASYNCHRONIZED); size_t filter_name_len = strlen(filter_name); region_filter_args *args = (region_filter_args*) f_args; region_table_t *regions = args->regions; LOG_DEBUG_F("region_filter over %zu records\n", input_records->size); vcf_record_t *record; region_t *region = (region_t*) malloc (sizeof(region_t)); for (int i = 0; i < input_records->size; i++) { record = input_records->items[i]; // LOG_DEBUG_F("record = %s, %ld\n", record->chromosome, record->position); region->chromosome = strndup(record->chromosome, record->chromosome_len); region->start_position = record->position; region->end_position = record->position; int found = 0; if (args->type) { region->type = args->type; found = find_region_by_type(region, regions); } else { found = find_region(region, regions); } if (found) { // Add to the list of records that pass all checks for at least one region array_list_insert(record, passed); // LOG_DEBUG_F("%.*s, %ld passed\n", record->chromosome_len, record->chromosome, record->position); } else { // Add to the list of records that fail all checks for all regions annotate_failed_record(filter_name, filter_name_len, record); array_list_insert(record, failed); } free(region->chromosome); } free(region); return passed; }
gboolean gtk_css_node_declaration_remove_region (GtkCssNodeDeclaration **decl, GQuark region_quark) { guint pos; if (!find_region (*decl, region_quark, &pos)) return FALSE; gtk_css_node_declaration_make_writable_resize (decl, (char *) &get_regions (*decl)[pos] - (char *) *decl, 0, sizeof (GtkRegion)); (*decl)->n_regions--; return TRUE; }
void parse_array (int ** matrix, int * array, int * nextFree) { int col = 0; while (col < DIMENSIONS) { int row = 0; while (row < DIMENSIONS) { if (matrix[col][row] == 1) { int area = find_region (matrix, col, row); array[*nextFree] = area; *nextFree = *nextFree + 1; } row++; } col++; } return; }
void AbsScarRegionDetector::insert_point(float * d, bool is_correct){ if(!this->is_valid(d)) return; /* * try and optimistically find a region the float belongs to */ int id = find_region(d); // case: update an existing a group if(id > 0 || !is_correct){ this->update_train_regions(id,d,is_correct); //updates statistics. return; } // case: create a new group //create a new node. region_t * r = new region_t[1]; this->allocate_region(r,d); this->regions[this->n_regions] = r; this->n_regions++; this->update_train_regions(this->n_regions-1,d, is_correct); //add region //if we're full of space, make room for another region. if(this->n_regions == this->max_regions){ //if we're full. //find the region with the most similar dynamics that isn't //completely obstructed by another region. int merge_1=-1; int merge_2=-1; float score = 0; for(int i=0; i < this->n_regions; i++){ float tmp_score=0; int tmp_other = find_closest_region(i, &tmp_score); if(merge_1 < 0 || tmp_score > score){ score = tmp_score; merge_1 = i; merge_2 = tmp_other; } } merge_regions(merge_1, merge_2); this->n_regions--; } /* * */ }
gboolean gtk_css_node_declaration_has_region (const GtkCssNodeDeclaration *decl, GQuark region_quark, GtkRegionFlags *flags_return) { guint pos; if (!find_region (decl, region_quark, &pos)) { if (flags_return) *flags_return = 0; return FALSE; } if (flags_return) *flags_return = get_regions (decl)[pos].flags; return TRUE; }
void dual() { std::pair<double, int> *tmp = new std::pair<double, int>[m << 1]; for(int i = 0; i != m << 1; ++i) tmp[i] = std::make_pair(edges[i].angle, i); std::sort(tmp, tmp + (m << 1)); for(int i = 0; i != m << 1; ++i) { int eid = tmp[i].second; rank[eid] = et[edges[eid].u].size(); et[edges[eid].u].push_back(eid); } delete[] tmp; for(int i = 1; i <= n; ++i) { for(int j = 0; j != et[i].size(); ++j) if(!vis[et[i][j]]) find_region(i, et[i][j]); } }
void atari_stram_free( void *addr ) { BLOCK *block; DPRINTK( "atari_stram_free(addr=%p)\n", addr ); if (!(block = find_region( addr ))) { printk( KERN_ERR "Attempt to free non-allocated ST-RAM block at %p " "from %p\n", addr, __builtin_return_address(0) ); return; } DPRINTK( "atari_stram_free: found block (%p): size=%08lx, owner=%s, " "flags=%02x\n", block, block->size, block->owner, block->flags ); #ifdef CONFIG_STRAM_SWAP if (!max_swap_size) { #endif if (block->flags & BLOCK_GFP) { DPRINTK( "atari_stram_free: is kmalloced, order_size=%d\n", get_gfp_order(block->size) ); free_pages( (unsigned long)addr, get_gfp_order(block->size) ); } else goto fail; #ifdef CONFIG_STRAM_SWAP } else if (block->flags & (BLOCK_INSWAP|BLOCK_STATIC)) { DPRINTK( "atari_stram_free: is swap-alloced\n" ); free_stram_region( SWAP_NR(block->start), N_PAGES(block->size) ); } else goto fail; #endif remove_region( block ); return; fail: printk( KERN_ERR "atari_stram_free: cannot free block at %p " "(called from %p)\n", addr, __builtin_return_address(0) ); }
/** * Unregister MMIO region from a cell. * @param cell Cell the region belongs to. * @param start Region start address as it was passed to * mmio_region_register(). * * @see mmio_region_register */ void mmio_region_unregister(struct cell *cell, unsigned long start) { int index; spin_lock(&cell->mmio_region_lock); index = find_region(cell, start, 0); if (index >= 0) { for (/* empty */; index < cell->num_mmio_regions; index++) copy_region(cell, index + 1, index); /* * Ensure the last region move is visible before shrinking the * list. */ memory_barrier(); cell->num_mmio_regions--; } spin_unlock(&cell->mmio_region_lock); }
gboolean gtk_css_node_declaration_add_region (GtkCssNodeDeclaration **decl, GQuark region_quark, GtkRegionFlags flags) { GtkRegion *regions; guint pos; if (find_region (*decl, region_quark, &pos)) return FALSE; gtk_css_node_declaration_make_writable_resize (decl, (char *) &get_regions (*decl)[pos] - (char *) *decl, sizeof (GtkRegion), 0); (*decl)->n_regions++; regions = get_regions(*decl); regions[pos].class_quark = region_quark; regions[pos].flags = flags; return TRUE; }
int translate_desc(struct vhost_dev *dev, u64 addr, u32 len, struct iovec iov[], int iov_size) { const struct vhost_memory_region *reg; struct vhost_memory *mem; struct iovec *_iov; u64 s = 0; int ret = 0; rcu_read_lock(); mem = rcu_dereference(dev->memory); while ((u64)len > s) { u64 size; if (ret >= iov_size) { ret = -ENOBUFS; break; } reg = find_region(mem, addr, len); if (!reg) { ret = -EFAULT; break; } _iov = iov + ret; size = reg->memory_size - addr + reg->guest_phys_addr; _iov->iov_len = min((u64)len, size); _iov->iov_base = (void *)(unsigned long) (reg->userspace_addr + addr - reg->guest_phys_addr); s += size; addr += size; ++ret; } rcu_read_unlock(); return ret; }
static errval_t debug_dequeue(struct devq* q, regionid_t* rid, genoffset_t* offset, genoffset_t* length, genoffset_t* valid_data, genoffset_t* valid_length, uint64_t* flags) { errval_t err; struct debug_q* que = (struct debug_q*) q; assert(que->q->f.deq != NULL); err = que->q->f.deq(que->q, rid, offset, length, valid_data, valid_length, flags); if (err_is_fail(err)) { return err; } DEBUG("dequeued offset=%lu \n", *offset); struct memory_list* region = NULL; err = find_region(que, ®ion, *rid); if (err_is_fail(err)){ // region ids are checked bythe devq library, if we do not find // the region id when dequeueing here we do not have a consistant // view of two endpoints // // Add region if (que->regions == NULL) { printf("Adding region frirst %lu len \n", *offset + *length); que->regions = slab_alloc(&que->alloc_list); assert(que->regions != NULL); que->regions->rid = *rid; que->regions->not_consistent = true; // region is at least offset + length que->regions->length = *offset + *length; que->regions->next = NULL; // add the whole regions as a buffer que->regions->buffers = slab_alloc(&que->alloc); assert(que->regions->buffers != NULL); memset(que->regions->buffers, 0, sizeof(que->regions->buffers)); que->regions->buffers->offset = 0; que->regions->buffers->length = *offset + *length; que->regions->buffers->next = NULL; return SYS_ERR_OK; } struct memory_list* ele = que->regions; while (ele->next != NULL) { ele = ele->next; } printf("Adding region second %lu len \n", *offset + *length); // add the reigon ele->next = slab_alloc(&que->alloc_list); assert(ele->next != NULL); memset(que->regions->buffers, 0, sizeof(ele->next)); ele = ele->next; ele->rid = *rid; ele->next = NULL; ele->not_consistent = true; ele->length = *offset + *length; // add the whole regions as a buffer ele->buffers = slab_alloc(&que->alloc); assert(ele->buffers != NULL); memset(ele->buffers, 0, sizeof(ele->buffers)); ele->buffers->offset = 0; ele->buffers->length = *offset + *length; ele->buffers->next = NULL; return SYS_ERR_OK; } if (region->not_consistent) { if ((*offset + *length) > region->length) { region->length = *offset + *length; } } //check_consistency(region); // find the buffer struct memory_ele* buffer = region->buffers; if (buffer == NULL) { region->buffers = slab_alloc(&que->alloc); assert(region->buffers != NULL); region->buffers->offset = *offset; region->buffers->length = *length; region->buffers->next = NULL; region->buffers->prev = NULL; return SYS_ERR_OK; } if (buffer->next == NULL) { if (!buffer_in_bounds(*offset, *length, buffer->offset, buffer->length)) { insert_merge_buffer(que, region, buffer, *offset, *length); return SYS_ERR_OK; } else { return DEVQ_ERR_BUFFER_NOT_IN_USE; } } while (buffer->next != NULL) { if (*offset >= buffer->offset) { buffer = buffer->next; } else { if (!buffer_in_bounds(*offset, *length, buffer->offset, buffer->length)) { insert_merge_buffer(que, region, buffer, *offset, *length); return SYS_ERR_OK; } else { return DEVQ_ERR_BUFFER_NOT_IN_USE; } } } // insert after the last buffer if (!buffer_in_bounds(*offset, *length, buffer->offset, buffer->length)) { insert_merge_buffer(que, region, buffer, *offset, *length); return SYS_ERR_OK; } return DEVQ_ERR_BUFFER_NOT_IN_USE; }
bam_stats_t *bam1_stats(bam1_t *bam1, bam_stats_options_t *opts) { bam_stats_t *bam_stats = NULL; uint32_t bam_flag = (uint32_t) bam1->core.flag; if (bam_flag & BAM_FUNMAP) { // not mapped, then return bam_stats = bam_stats_new(); bam_stats->mapped = 0; return bam_stats; } if (opts->region_table) { region_t region; region.chromosome = opts->sequence_labels[bam1->core.tid]; region.start_position = bam1->core.pos; region.end_position = region.start_position + bam1->core.l_qseq; region.strand = NULL; region.type = NULL; if (find_region(®ion, opts->region_table)) { bam_stats = bam_stats_new(); } else { return NULL; } } else { bam_stats = bam_stats_new(); } // mapped !! bam_stats->mapped = 1; bam_stats->strand = (int) ((bam_flag & BAM_FREVERSE) > 0); // number of errors bam_stats->num_errors = bam_aux2i(bam_aux_get(bam1, "NM")); // cigar handling: number of indels and length uint32_t cigar_int, *cigar = bam1_cigar(bam1); int num_cigar_ops = (int) bam1->core.n_cigar; for (int j = 0; j < num_cigar_ops; j++) { cigar_int = cigar[j]; switch (cigar_int & BAM_CIGAR_MASK) { case BAM_CINS: //I: insertion to the reference case BAM_CDEL: //D: deletion from the reference bam_stats->num_indels++; bam_stats->indels_length += (cigar_int >> BAM_CIGAR_SHIFT); break; } } // quality bam_stats->quality = bam1->core.qual; // unique alignment if (!(bam_flag & BAM_FSECONDARY)) { bam_stats->unique_alignment = 1; } // handling pairs bam_stats->single_end = 1; if (bam_flag & BAM_FPAIRED) { bam_stats->single_end = 0; if (bam_flag & BAM_FUNMAP) { if (bam_flag & BAM_FREAD1) { bam_stats->unmapped_pair_1 = 1; } else { bam_stats->unmapped_pair_2 = 1; } } else { if (bam_flag & BAM_FREAD1) { bam_stats->mapped_pair_1 = 1; } else { bam_stats->mapped_pair_2 = 1; } } if (!(bam_flag & BAM_FUNMAP) && !(bam_flag & BAM_FMUNMAP) && (bam_flag & BAM_FPROPER_PAIR)) { bam_stats->isize = abs(bam1->core.isize); } } // mapping length char *bam_seq = bam1_seq(bam1); int seq_len = bam1->core.l_qseq; bam_stats->seq_length = seq_len; // nucleotide content for (int i = 0; i < seq_len; i++) { switch (bam1_seqi(bam_seq, i)) { case 1: bam_stats->num_As++; break; case 2: bam_stats->num_Cs++; break; case 4: bam_stats->num_Gs++; break; case 8: bam_stats->num_Ts++; break; case 15: bam_stats->num_Ns++; break; } } bam_stats->num_GCs = bam_stats->num_Gs + bam_stats->num_Cs; return bam_stats; }
void lay_ebanregion( const gmltag * entry ) { region_lay_tag * reg; banner_lay_tag * reg_ban; int k; bool region_deleted; if( !GlobalFlags.firstpass ) { scan_start = scan_stop + 1; eat_lay_sub_tag(); return; // process during first pass only } if( ProcFlags.lay_xxx == el_banregion ) { // :banregion was last tag ProcFlags.lay_xxx = el_ebanregion; prev_reg = NULL; reg_ban = NULL; region_deleted = false; if( sum_count == 1 && wk.refnum > 0 ) {// banregion delete request if( del_ban != NULL ) { // banner delete request, too reg_ban = del_ban; } else { reg_ban = curr_ban; } reg = find_region( reg_ban ); if( reg != NULL) { // banregion delete if( prev_reg == NULL ) { reg_ban->region = reg->next; } else { prev_reg->next = reg->next; } mem_free( reg ); reg = NULL; region_deleted = true; // processing complete } } if( !region_deleted ) { // no region delete request, or prev_reg = NULL; // region not found if( del_ban != NULL ) { reg_ban = del_ban; } else { reg_ban = curr_ban; } reg = find_region( reg_ban ); if( reg == NULL ) { // not found, new region reg = mem_alloc( sizeof( region_lay_tag ) ); memcpy( reg, &wk, sizeof( region_lay_tag ) ); if( prev_reg == NULL ) {// first region in banner reg_ban->region = reg; } else { prev_reg->next = reg; } } else { // modify existing banregion for( k = 0; k < att_count; ++k ) { if( count[k] ) {// change specified attribute switch( banregion_att[k] ) { case e_indent: memcpy( &(reg->indent), &(wk.indent), sizeof( wk.indent ) ); break; case e_hoffset: memcpy( &(reg->hoffset), &(wk.hoffset), sizeof( wk.hoffset ) ); break; case e_width: memcpy( &(reg->width), &(wk.width), sizeof( wk.width ) ); break; case e_voffset: memcpy( &(reg->voffset), &(wk.voffset), sizeof( wk.voffset ) ); break; case e_depth: memcpy( &(reg->depth), &(wk.depth), sizeof( wk.depth ) ); break; case e_font: reg->font = wk.font; break; case e_refnum: reg->refnum = wk.refnum; break; case e_region_position: reg->region_position = wk.region_position; break; case e_pouring: reg->pouring = wk.pouring; break; case e_script_format: reg->script_format = wk.script_format; break; case e_contents: memcpy( &(reg->contents), &(wk.contents), sizeof( wk.contents ) ); break; default: break; } } } } } } else { g_err( err_no_lay, &(entry->tagname[1]), entry->tagname ); err_count++; file_mac_info(); } scan_start = scan_stop + 1; return; }
END_TEST START_TEST (gff_file_regions) { region_t region; // Check regions in chr1 region.chromosome = "1"; region.start_position = 10000000; region.end_position = 10001000; fail_if(!find_region(®ion, region_table), "Region 1:10000000-10001000 must have been inserted"); region.start_position = 10010000; region.end_position = 10010100; fail_if(!find_region(®ion, region_table), "Region 1:10010000-10010100 must have been inserted"); // Check regions in chr2 region.chromosome = "2"; region.start_position = 20020000; region.end_position = 20025000; fail_if(!find_region(®ion, region_table), "Region 2:20020000-20025000 must have been inserted"); region.start_position = 20000000; region.end_position = 20001000; fail_if(!find_region(®ion, region_table), "Region 2:20000000-20001000 must have been inserted"); region.start_position = 20010000; region.end_position = 20010100; fail_if(!find_region(®ion, region_table), "Region 2:20010000-20010100 must have been inserted"); // Check regions in chr3 region.chromosome = "3"; region.start_position = 30020000; region.end_position = 30025000; fail_if(!find_region(®ion, region_table), "Region 3:30020000-30025000 must have been inserted"); region.start_position = 30000000; region.end_position = 30001000; fail_if(!find_region(®ion, region_table), "Region 3:30000000-30001000 must have been inserted"); // Check regions in chr20 region.chromosome = "20"; region.start_position = 20010000; region.end_position = 20010100; fail_if(!find_region(®ion, region_table), "Region 20:20010000-20010100 must have been inserted"); // Check regions in chr22 region.chromosome = "22"; region.start_position = 22000000; region.end_position = 22001000; fail_if(!find_region(®ion, region_table), "Region 22:22000000-22001000 must have been inserted"); region.start_position = 22010000; region.end_position = 22010100; fail_if(!find_region(®ion, region_table), "Region 22:22010000-22010100 must have been inserted"); // Check regions in chrX region.chromosome = "X"; region.start_position = 95020000; region.end_position = 95025000; fail_if(!find_region(®ion, region_table), "Region X:95020000-95025000 must have been inserted"); }
static errval_t debug_enqueue(struct devq* q, regionid_t rid, genoffset_t offset, genoffset_t length, genoffset_t valid_data, genoffset_t valid_length, uint64_t flags) { assert(length > 0); DEBUG("enqueue offset %"PRIu64" \n", offset); errval_t err; struct debug_q* que = (struct debug_q*) q; // find region struct memory_list* region = NULL; err = find_region(que, ®ion, rid); if (err_is_fail(err)){ return err; } check_consistency(region); // find the buffer struct memory_ele* buffer = region->buffers; if (region->buffers == NULL) { return DEVQ_ERR_BUFFER_ALREADY_IN_USE; } // the only buffer if (buffer->next == NULL) { if (buffer_in_bounds(offset, length, buffer->offset, buffer->length)) { err = que->q->f.enq(que->q, rid, offset, length, valid_data, valid_length, flags); if (err_is_fail(err)) { return err; } remove_split_buffer(que, region, buffer, offset, length); return SYS_ERR_OK; } else { printf("Bounds check failed only buffer offset=%lu length=%lu " " buf->offset=%lu buf->len=%lu\n", offset, length, buffer->offset, buffer->length); dump_history(que); dump_list(region); return DEVQ_ERR_INVALID_BUFFER_ARGS; } } // more than one buffer while (buffer != NULL) { if (buffer_in_bounds(offset, length, buffer->offset, buffer->length)){ err = que->q->f.enq(que->q, rid, offset, length, valid_data, valid_length, flags); if (err_is_fail(err)) { return err; } remove_split_buffer(que, region, buffer, offset, length); return SYS_ERR_OK; } buffer = buffer->next; } printf("Did not find region offset=%ld length=%ld \n", offset, length); dump_history(que); dump_list(region); return DEVQ_ERR_INVALID_BUFFER_ARGS; }