/* * This is main public interface: somehow allocate a ST-RAM block * * - If we're before mem_init(), we have to make a static allocation. The * region is taken in the kernel data area (if the kernel is in ST-RAM) or * from the start of ST-RAM (if the kernel is in TT-RAM) and added to the * rsvd_stram_* region. The ST-RAM is somewhere in the middle of kernel * address space in the latter case. * * - If mem_init() already has been called, try with __get_dma_pages(). * This has the disadvantage that it's very hard to get more than 1 page, * and it is likely to fail :-( * */ void *atari_stram_alloc(long size, const char *owner) { void *addr = NULL; BLOCK *block; int flags; DPRINTK("atari_stram_alloc(size=%08lx,owner=%s)\n", size, owner); if (!mem_init_done) return alloc_bootmem_low(size); else { /* After mem_init(): can only resort to __get_dma_pages() */ addr = (void *)__get_dma_pages(GFP_KERNEL, get_order(size)); flags = BLOCK_GFP; DPRINTK( "atari_stram_alloc: after mem_init, " "get_pages=%p\n", addr ); } if (addr) { if (!(block = add_region( addr, size ))) { /* out of memory for BLOCK structure :-( */ DPRINTK( "atari_stram_alloc: out of mem for BLOCK -- " "freeing again\n" ); free_pages((unsigned long)addr, get_order(size)); return( NULL ); } block->owner = owner; block->flags |= flags; } return( addr ); }
struct region * create_gas_cloud(struct level *lev, xchar x, xchar y, int radius, int damage) { struct region *cloud; int i, nrect; struct nhrect tmprect; cloud = create_region(NULL, 0); nrect = radius; tmprect.lx = x; tmprect.hx = x; tmprect.ly = y - (radius - 1); tmprect.hy = y + (radius - 1); for (i = 0; i < nrect; i++) { add_rect_to_reg(cloud, &tmprect); tmprect.lx--; tmprect.hx++; tmprect.ly++; tmprect.hy--; } cloud->ttl = rn1(3, 4); if (!in_mklev && !flags.mon_moving) set_heros_fault(cloud); /* assume player has created it */ cloud->inside_f = INSIDE_GAS_CLOUD; cloud->expire_f = EXPIRE_GAS_CLOUD; cloud->arg = damage; cloud->visible = TRUE; cloud->effect_id = dbuf_effect(E_MISC, E_gascloud); add_region(lev, cloud); return cloud; }
void parse_region(FILE *fp, World *w) { char texture_name[STRING_TOKEN_MAX_LENGTH]; int texture_index; Region r; if (get_real_token(fp, &r.floor) != Token_real) parse_error("number expected"); if (get_real_token(fp, &r.ceiling) != Token_real) parse_error("number expected"); /* floor texture */ if (get_string_token(fp, texture_name) != Token_string) parse_error("texture name expected"); texture_index = get_texture_index(texture_name); if (texture_index < 0 || texture_index > TABLE_SIZE(w->textures)) parse_error("non-existent texture"); else r.floor_tex = WORLD_TEXTURE(w, texture_index); /* ceiling texture */ if (get_string_token(fp, texture_name) != Token_string) parse_error("texture name expected"); if (strcmp(texture_name, "sky") == 0) r.ceiling_tex = NULL; else { texture_index = get_texture_index(texture_name); if (texture_index < 0 || texture_index > TABLE_SIZE(w->textures)) parse_error("non-existent texture"); else r.ceiling_tex = WORLD_TEXTURE(w, texture_index); } add_region(w, &r); }
rc_t ref_walker_add_range( struct ref_walker * self, const char * name, const uint64_t start, const uint64_t end ) { rc_t rc = 0; if ( self == NULL ) rc = RC( rcApp, rcNoTarg, rcConstructing, rcParam, rcNull ); else rc = add_region( &self->regions, name, start, end ); return rc; }
rc_t parse_and_add_region( BSTree * regions, const char * s ) { uint64_t start, end; char name[ 4096 ]; parse_definition( s, name, sizeof name, &start, &end ); if ( name[ 0 ] == 0 ) return RC( rcApp, rcNoTarg, rcConstructing, rcMemory, rcExhausted ); else return add_region( regions, name, start, end ); }
void setup() { set_name( "pumpkin" ); set_information( "Pumpkin is a large orange ball shaped town.\n"); add_region( "round", "Pumpkins which are round.", "/d/dist/start/entrance", "/std/nationality/accents/regional/round"); add_region( "square", "Sto Lat is the second biggest city in the Morporkian kingdom, " "it sits on the river Ankh on the way to the Carrack " "Mountains. It is a harder starting location than " "Ankh-Morpork but close enough that it is not that much of an " "issue.", "/d/dist/start/entrance", "/std/nationality/accents/regional/square"); set_language("pumpkin"); set_currency_area("Pumpkin"); set_default_start_location("/d/am/buildings/drum/mendeddrum"); }
void TDeviceFileInput::copy_contents(const TDeviceFileInput& new_device_input) { int i; MaterialParam j; MaterialParamInput new_param_input; DopingInput new_doping; StructureInput new_structure; for (i=0;i<new_device_input.number_grid;i++) add_grid(*(new_device_input.grid_ptr+i)); for (i=0;i<new_device_input.number_doping;i++) { new_doping.length=(new_device_input.doping_ptr+i)->length; new_doping.acceptor_function=(new_device_input.doping_ptr+i)->acceptor_function->create_copy(); new_doping.donor_function=(new_device_input.doping_ptr+i)->donor_function->create_copy(); new_doping.acceptor_degeneracy=(new_device_input.doping_ptr+i)->acceptor_degeneracy; new_doping.acceptor_level=(new_device_input.doping_ptr+i)->acceptor_level; new_doping.donor_degeneracy=(new_device_input.doping_ptr+i)->donor_degeneracy; new_doping.donor_level=(new_device_input.doping_ptr+i)->donor_level; add_doping(new_doping); } for (i=0;i<new_device_input.number_structure;i++) { new_structure.material_type=(new_device_input.structure_ptr+i)->material_type; new_structure.alloy_type=(new_device_input.structure_ptr+i)->alloy_type; new_structure.length=(new_device_input.structure_ptr+i)->length; new_structure.alloy_function=(new_device_input.structure_ptr+i)->alloy_function->create_copy(); add_structure(new_structure); } for (i=0;i<new_device_input.number_region;i++) add_region(*(new_device_input.region_ptr+i)); for (i=0;i<new_device_input.number_cavity;i++) add_cavity(*(new_device_input.cavity_ptr+i)); for (i=0;i<new_device_input.number_mirror;i++) add_mirror(*(new_device_input.mirror_ptr+i)); radius=new_device_input.radius; for (j=1;j<=MAT_MAX_NUMBER_PARAMETERS;j++) { for (i=0;i<new_device_input.number_material_param[j-1];i++) { new_param_input.length=(new_device_input.material_param_input[j-1]+i)->length; new_param_input.material_model= new TMaterialParamModel(*((new_device_input.material_param_input[j-1]+i)->material_model)); add_material_param(j,new_param_input); } } }
static rc_t ref_walker_prepare_1_src( struct ref_walker * self, const char * name ) { VPath * path = NULL; const VPath * local_cache = NULL; const KFile * remote_file = NULL; rc_t rc = VFSManagerResolveSpec ( self->vfs_mgr, name, &path, &remote_file, &local_cache, true ); if ( rc != 0 ) { PLOGERR( klogErr, ( klogErr, rc, "cannot resolve '$(n)' via VFSManager", "n=%s", name ) ); } else { char buffer[ 4096 ]; size_t num_read; rc = VPathReadPath ( path, buffer, sizeof buffer, &num_read ); if ( rc != 0 ) { PLOGERR( klogErr, ( klogErr, rc, "cannot read path from vpath for '$(n)'", "n=%s", name ) ); } else { if ( rc == 0 ) { int path_type = ( VDBManagerPathType ( self->vmgr, "%s", buffer ) & ~ kptAlias ); if ( path_type == kptDatabase ) { const ReferenceList * reflist; uint32_t options = ( ereferencelist_usePrimaryIds | ereferencelist_useSecondaryIds | ereferencelist_useEvidenceIds ); rc = ReferenceList_MakePath( &reflist, self->vmgr, name, options, 0, NULL, 0 ); if ( rc != 0 ) { PLOGERR( klogErr, ( klogErr, rc, "cannot create ReferenceList for '$(n)'", "n=%s", name ) ); } else { uint32_t count; rc = ReferenceList_Count( reflist, &count ); if ( rc != 0 ) { PLOGERR( klogErr, ( klogErr, rc, "ReferenceList_Count() for '$(n)' failed", "n=%s", name ) ); } else { uint32_t idx; for ( idx = 0; idx < count && rc == 0; ++idx ) { const ReferenceObj * refobj; rc = ReferenceList_Get( reflist, &refobj, idx ); if ( rc != 0 ) { LOGERR( klogInt, rc, "ReferenceList_Get() failed" ); } else { const char * seqid; rc = ReferenceObj_SeqId( refobj, &seqid ); if ( rc == 0 ) { INSDC_coord_len seqlen; rc = ReferenceObj_SeqLength( refobj, &seqlen ); if ( rc == 0 ) { rc = add_region( &self->regions, seqid, 0, seqlen - 1 ); } } ReferenceObj_Release( refobj ); } } } ReferenceList_Release( reflist ); } } } } KFileRelease( remote_file ); VPathRelease ( local_cache ); VPathRelease ( path ); } return rc; }
int main(void) { const struct dt_property *names, *ranges; struct mem_region *r; unsigned int i, l, c; uint64_t *rangep; const char *name; void *buf; /* Use malloc for the heap, so valgrind can find issues. */ skiboot_heap.start = (long)real_malloc(TEST_HEAP_SIZE); skiboot_heap.len = TEST_HEAP_SIZE; skiboot_os_reserve.len = skiboot_heap.start; dt_root = dt_new_root(""); dt_add_property_cells(dt_root, "#address-cells", 2); dt_add_property_cells(dt_root, "#size-cells", 2); buf = real_malloc(1024*1024); add_mem_node((unsigned long)buf, 1024*1024); /* Now convert. */ mem_region_init(); /* create our reservations */ for (i = 0; i < ARRAY_SIZE(test_regions); i++) mem_reserve(test_regions[i].name, test_regions[i].addr, 0x1000); /* release unused */ mem_region_release_unused(); /* and create reservations */ mem_region_add_dt_reserved(); /* ensure we can't create further reservations */ r = new_region("test.4", 0x5000, 0x1000, NULL, REGION_RESERVED); assert(!add_region(r)); /* check dt properties */ names = dt_find_property(dt_root, "reserved-names"); ranges = dt_find_property(dt_root, "reserved-ranges"); assert(names && ranges); /* walk through names & ranges properies, ensuring that the test * regions are all present */ for (name = names->prop, rangep = (uint64_t *)ranges->prop, c = 0; name < names->prop + names->len; name += l, rangep += 2) { uint64_t addr; addr = dt_get_number(rangep, 2); l = strlen(name) + 1; for (i = 0; i < ARRAY_SIZE(test_regions); i++) { if (strcmp(test_regions[i].name, name)) continue; assert(test_regions[i].addr == addr); assert(!test_regions[i].found); test_regions[i].found = true; c++; } } assert(c == ARRAY_SIZE(test_regions)); dt_free(dt_root); real_free(buf); real_free((void *)(long)skiboot_heap.start); return 0; }
int main(int argc, char **argv) { XEvent event; config_init(); parse_cli_options(argc, argv); config_read(); mixer_init(config.mixer_device, config.verbose, (const char **)config.exclude_channel); mixer_set_channel(0); display = XOpenDisplay(config.display_name); if (display == NULL) { const char *name; if (config.display_name) { name = config.display_name; } else { name = getenv("DISPLAY"); if (name == NULL) { fprintf(stderr, "wmix:error: Unable to open display, variable $DISPLAY not set\n"); return EXIT_FAILURE; } } fprintf(stderr, "wmix:error: Unable to open display \"%s\"\n", name); return EXIT_FAILURE; } display_width = (float)DisplayWidth(display, DefaultScreen(display)) / 4.0; display_height = (float)DisplayHeight(display, DefaultScreen(display)) / 2.0; dockapp_init(display); new_window("wmix", 64, 64); new_osd(DisplayWidth(display, DefaultScreen(display)) - 200, 60); if (config.mmkeys) mmkey_install(display); config_release(); blit_string("wmix " VERSION); scroll_text(3, 4, 57, true); ui_update(); /* add click regions */ add_region(1, 37, 36, 25, 25); /* knob */ add_region(2, 4, 42, 27, 15); /* balancer */ add_region(3, 2, 26, 7, 10); /* previous channel */ add_region(4, 10, 26, 7, 10); /* next channel */ add_region(5, 39, 14, 20, 7); /* mute toggle */ add_region(6, 4, 14, 13, 7); /* rec toggle */ add_region(10, 3, 4, 56, 7); /* re-scroll current channel name */ /* setup up/down signal handler */ create_pid_file(); signal(SIGUSR1, (void *) signal_catch); signal(SIGUSR2, (void *) signal_catch); while (true) { if (button_pressed || slider_pressed || (XPending(display) > 0)) { XNextEvent(display, &event); switch (event.type) { case KeyPress: if (key_press_event(&event.xkey)) idle_loop = 0; break; case Expose: redraw_window(); break; case ButtonPress: button_press_event(&event.xbutton); idle_loop = 0; break; case ButtonRelease: button_release_event(&event.xbutton); idle_loop = 0; break; case MotionNotify: /* process cursor change, or drag events */ motion_event(&event.xmotion); idle_loop = 0; break; case LeaveNotify: /* go back to standard cursor */ if ((!button_pressed) && (!slider_pressed)) set_cursor(NORMAL_CURSOR); break; case DestroyNotify: XCloseDisplay(display); return EXIT_SUCCESS; default: break; } } else { usleep(100000); scroll_text(3, 4, 57, false); /* rescroll message after some delay */ if (idle_loop++ > 256) { scroll_text(3, 4, 57, true); idle_loop = 0; } /* get rid of OSD after a few seconds of idle */ if ((idle_loop > 15) && osd_mapped() && !button_pressed) { unmap_osd(); idle_loop = 0; } if (mixer_is_changed()) ui_update(); } } return EXIT_SUCCESS; }
/* * This is main public interface: somehow allocate a ST-RAM block * There are three strategies: * * - If we're before mem_init(), we have to make a static allocation. The * region is taken in the kernel data area (if the kernel is in ST-RAM) or * from the start of ST-RAM (if the kernel is in TT-RAM) and added to the * rsvd_stram_* region. The ST-RAM is somewhere in the middle of kernel * address space in the latter case. * * - If mem_init() already has been called and ST-RAM swapping is enabled, * try to get the memory from the (pseudo) swap-space, either free already * or by moving some other pages out of the swap. * * - If mem_init() already has been called, and ST-RAM swapping is not * enabled, the only possibility is to try with __get_dma_pages(). This has * the disadvantage that it's very hard to get more than 1 page, and it is * likely to fail :-( * */ void *atari_stram_alloc( long size, unsigned long *start_mem, const char *owner ) { void *addr = NULL; BLOCK *block; int flags; DPRINTK( "atari_stram_alloc(size=%08lx,*start_mem=%08lx,owner=%s)\n", size, start_mem ? *start_mem : 0xffffffff, owner ); if (start_mem && mem_init_done) { printk( KERN_ERR "atari_stram_alloc called with start_mem!=NULL " "after mem_init() from %p\n", __builtin_return_address(0) ); return( NULL ); } if (!start_mem && !mem_init_done) { printk( KERN_ERR "atari_stram_alloc called with start_mem==NULL " "before mem_init() from %p\n", __builtin_return_address(0) ); return( NULL ); } size = ALIGN_IF_SWAP(size); DPRINTK( "atari_stram_alloc: rounded size = %08lx\n", size ); if (!mem_init_done) { /* before mem_init(): allocate "statically", i.e. either in the kernel * data space (current end in *start_mem), or at the end of currently * reserved ST-RAM. */ if (kernel_in_stram) { /* Get memory from kernel data space */ *start_mem = ALIGN_IF_SWAP(*start_mem); addr = (void *)*start_mem; *start_mem += size; DPRINTK( "atari_stram_alloc: pre-mem_init and k/ST: " "shifted start_mem to %08lx, addr=%p\n", *start_mem, addr ); } else { /* Get memory from rsvd_stram_beg */ if (rsvd_stram_end + size < stram_end) { addr = (void *) rsvd_stram_end; rsvd_stram_end += size; DPRINTK( "atari_stram_alloc: pre-mem_init and k/TT: " "shifted rsvd_stram_end to %08lx, addr=%p\n", rsvd_stram_end, addr ); } } flags = BLOCK_STATIC; } #ifdef CONFIG_STRAM_SWAP else if (max_swap_size) { /* If swapping is active (can only be the case after mem_init()!): * make some free space in the swap "device". */ DPRINTK( "atari_stram_alloc: after mem_init, swapping ok, " "calling get_region\n" ); addr = get_stram_region( N_PAGES(size) ); flags = BLOCK_INSWAP; } #endif else { /* After mem_init() and no swapping: can only resort to * __get_dma_pages() */ addr = (void *)__get_dma_pages(GFP_KERNEL, get_gfp_order(size)); flags = BLOCK_GFP; DPRINTK( "atari_stram_alloc: after mem_init, swapping off, " "get_pages=%p\n", addr ); } if (addr) { if (!(block = add_region( addr, size ))) { /* out of memory for BLOCK structure :-( */ DPRINTK( "atari_stram_alloc: out of mem for BLOCK -- " "freeing again\n" ); if (flags == BLOCK_STATIC) rsvd_stram_end -= size; #ifdef CONFIG_STRAM_SWAP else if (flags == BLOCK_INSWAP) free_stram_region( SWAP_NR(addr), N_PAGES(size) ); #endif else free_pages( (unsigned long)addr, get_gfp_order(size)); return( NULL ); } block->owner = owner; block->flags |= flags; } return( addr ); }
static void region_mix_callback(GtkWidget *w, gpointer context) { if ((current_region != -1) && (selected_channel())) add_region(region_list_position_to_id(current_region), selected_channel()); }