static gboolean concat_frags (GList *list) { GList *l; guchar *ptr; gulong length = 0; gulong initial_length; gulong initial_offset; GIOPRecvBuffer *head; head = list->data; length = head->msg.header.message_size; initial_offset = (head->cur - head->message_body); initial_length = (head->end - head->cur); length += initial_offset - 12; /* include what we read of the header */ g_assert (head->free_body); if (alloc_buffer (head, head->message_body, length)) { dprintf (ERRORS, "failed to allocate fragment collation buffer"); return TRUE; } head->left_to_read = 0; head->cur = head->message_body + initial_offset; ptr = head->cur + initial_length; for (l = list->next; l; l = l->next) { gulong len; GIOPRecvBuffer *buf = l->data; len = buf->end - buf->cur; memcpy (ptr, buf->cur, len); ptr+= len; } head->end = ptr; return FALSE; }
int dfs_ftruncate(struct file *filp, off64_t size) { struct inode *inode; int rc; unsigned int blocks; blkno_t blk; struct buf *buf; if (size > DFS_MAXFILESIZE) return -EFBIG; inode = (struct inode *) filp->data; if (S_ISDIR(inode->desc->mode)) return -EISDIR; if (size < 0) return -EINVAL; if (size == inode->desc->size) return 0; blocks = ((size_t) size + inode->fs->blocksize - 1) / inode->fs->blocksize; if (size > inode->desc->size) { while (inode->desc->blocks < blocks) { blk = expand_inode(inode); if (blk == NOBLOCK) return -ENOSPC; buf = alloc_buffer(inode->fs->cache, blk); if (!buf) return -EIO; memset(buf->data, 0, inode->fs->blocksize); mark_buffer_updated(inode->fs->cache, buf); release_buffer(inode->fs->cache, buf); } } else { rc = truncate_inode(inode, blocks); if (rc < 0) return rc; } inode->desc->size = size; mark_inode_dirty(inode); filp->flags |= F_MODIFIED; return 0; }
static void report( neko_vm *vm, value exc ) { #if OSX CFStringRef title = CFSTR("Uncaught exception"); CFStringRef message; #endif int i = 0; buffer b = alloc_buffer(NULL); value st = neko_exc_stack(vm); if( val_array_size(st) > 20 ) { i = val_array_size(st) - 20; buffer_append(b,"...\n"); } for(i;i<val_array_size(st);i++) { value s = val_array_ptr(st)[i]; if( val_is_null(s) ) buffer_append(b,"Called from a C function\n"); else if( val_is_string(s) ) { buffer_append(b,"Called from "); buffer_append(b,val_string(s)); buffer_append(b," (no debug available)\n"); } else if( val_is_array(s) && val_array_size(s) == 2 && val_is_string(val_array_ptr(s)[0]) && val_is_int(val_array_ptr(s)[1]) ) { buffer_append(b,"Called from "); buffer_append(b,val_string(val_array_ptr(s)[0])); buffer_append(b," line "); val_buffer(b,val_array_ptr(s)[1]); buffer_append(b,"\n"); } else { buffer_append(b,"Called from "); val_buffer(b,s); buffer_append(b,"\n"); } } val_buffer(b,exc); #if _WIN32 MessageBox(NULL,val_string(buffer_to_string(b)),"Uncaught exception",MB_OK | MB_ICONERROR); #elif OSX message = CFStringCreateWithCString(NULL,val_string(buffer_to_string(b)), kCFStringEncodingUTF8); CFUserNotificationDisplayNotice(0,0,NULL,NULL,NULL,title,message,NULL); #elif LINUX fprintf(stderr,"Uncaught Exception: %s\n",val_string(buffer_to_string(b))); #endif }
static void test_enqueue_and_dequeue_message_queue() { message_queue *queue = create_message_queue(); assert_true( queue != NULL ); buffer *enq_buf = alloc_buffer(); assert_true( enqueue_message( queue, enq_buf ) ); assert_int_equal( queue->length, 1 ); buffer *deq_buf = dequeue_message( queue ); assert_true( deq_buf == enq_buf ); free_buffer( deq_buf ); assert_int_equal( queue->length, 0 ); deq_buf = dequeue_message( queue ); assert_true( deq_buf == NULL ); assert_int_equal( queue->length, 0 ); assert_true( delete_message_queue( queue ) ); }
buffer *new_buffer(void) { buffer *b = alloc_buffer(cur_buffer); if (b) { clear_buffer(b); if (cur_buffer) { add(&b->b_node, &cur_buffer->b_node); } else { add_head(&buffers, &b->b_node); } cur_buffer = b; } return b; }
char *get_write_ptr (netbuffer_t *H, int len) { netbuffer_t *X = H->prev, *Y; assert ((unsigned long) len < NET_BUFFER_SIZE); assert (H->state == NB_MAGIC_HEAD || H->state == NB_MAGIC_BUSYHEAD); if (X->wptr + len <= X->end) { return X->wptr; } Y = alloc_buffer(); if (!Y) { return 0; } H->extra++; X->next = Y; Y->prev = X; Y->next = H; H->prev = Y; if (X->pptr) { Y->pptr = Y->rptr; } assert (Y->wptr + len <= Y->end); return Y->wptr; }
static void assert_backpatches_branches(unsigned char expected_prefix, unsigned char expected_opc, unsigned char expected_target, struct basic_block *branch_bb, struct basic_block *target_bb) { struct buffer *buf; branch_bb->is_emitted = false; target_bb->is_emitted = false; buf = alloc_buffer(); emit_body(branch_bb, buf); assert_prefixed_mem_insn_5(expected_prefix, expected_opc, 0x00, 0x00, 0x00, 0x00, buffer_ptr(buf)); emit_body(target_bb, buf); assert_prefixed_mem_insn_5(expected_prefix, expected_opc, expected_target, 0x00, 0x00, 0x00, buffer_ptr(buf)); free_buffer(buf); }
static void echo_request_interval( void *user_data ) { struct switch_info *sw_info = user_data; buffer *buf = alloc_buffer(); echo_body *body = append_back_buffer( buf, sizeof( echo_body ) ); body->datapath_id = htonll( switch_info.datapath_id ); struct timespec now; clock_gettime( CLOCK_MONOTONIC, &now ); body->sec = htonl( ( uint32_t ) now.tv_sec ); body->nsec = htonl( ( uint32_t ) now.tv_nsec ); sw_info->echo_request_xid = generate_xid(); int err = ofpmsg_send_echorequest( sw_info, sw_info->echo_request_xid, buf ); if ( err < 0 ) { switch_event_disconnected( &switch_info ); return; } switch_set_timeout( ECHO_REPLY_TIMEOUT, echo_reply_timeout, NULL ); }
void wolf(t_trd *t) { t->time = 0; t->tp = 0; t->dtp = 0; t->posx = 10; t->posy = 9.5; t->dirx = -1; t->diry = 0; t->plx = 0; t->ply = 0.66; t->hit[0] = 0; t->hit[1] = 0; t->hit[2] = 0; t->hit[3] = 0; map_generator(t); show_me_map(t); alloc_buffer(t); calc(t); free_buffer(t); }
/** put_env : var:string -> val:string -> void <doc>Set some environment variable value</doc> **/ static value put_env( value e, value v ) { #ifdef HX_WINRT // Do nothing return alloc_null(); #elif defined(NEKO_WINDOWS) val_check(e,string); val_check(v,string); buffer b = alloc_buffer(0); val_buffer(b,e); buffer_append_sub(b,"=",1); val_buffer(b,v); if( putenv(buffer_data(b)) != 0 ) return alloc_null(); #else val_check(e,string); val_check(v,string); if( setenv(val_string(e),val_string(v),1) != 0 ) return alloc_null(); #endif return alloc_bool(true); }
/** regexp_replace_fun : 'regexp -> from:string -> f:('regexp -> any) -> string <doc>Perform a replacement of all matched substrings by calling [f] for every match</doc> **/ static value regexp_replace_fun( value o, value s, value f ) { val_check_kind(o,k_regexp); val_check(s,string); val_check_function(f,1); { pcredata *d = PCRE(o); buffer b = alloc_buffer(NULL); int pos = 0; int len = val_strlen(s); const char *str = val_string(s); d->str = s; while( pcre_exec(d->r,NULL,str,len,pos,0,d->matchs,d->nmatchs * 3) >= 0 ) { buffer_append_sub(b,str+pos,d->matchs[0] - pos); val_buffer(b,val_call1(f,o)); pos = d->matchs[1]; } d->str = alloc_null(); buffer_append_sub(b,str+pos,len-pos); return buffer_to_string(b); } }
static value ssl_read( value ssl ) { int len, bufsize = 256; buffer b; unsigned char buf[256]; mbedtls_ssl_context *ctx; val_check_kind(ssl,k_ssl); ctx = val_ssl(ssl); b = alloc_buffer(NULL); while( true ) { POSIX_LABEL(read_again); len = mbedtls_ssl_read( ctx, buf, bufsize ); if( len == SOCKET_ERROR ) { HANDLE_EINTR(read_again); return block_error(); } if( len == 0 ) break; buffer_append_sub(b,(const char *)buf,len); } return buffer_to_string(b); }
static value alloc_result( connection *c, MYSQL_RES *r ) { result *res = (result*)alloc(sizeof(result)); value o = alloc_abstract(k_result,res); int num_fields = mysql_num_fields(r); int i,j; MYSQL_FIELD *fields = mysql_fetch_fields(r); res->r = r; res->conv_date = c->conv_date; res->conv_bytes = c->conv_bytes; res->conv_string = c->conv_string; res->current = NULL; res->nfields = num_fields; res->fields_ids = (field*)alloc_private(sizeof(field)*num_fields); res->fields_convs = (CONV*)alloc_private(sizeof(CONV)*num_fields); for(i=0;i<num_fields;i++) { field id; if( strchr(fields[i].name,'(') ) id = val_id("???"); // looks like an inner request : prevent hashing + cashing it else { id = val_id(fields[i].name); for(j=0;j<i;j++) if( res->fields_ids[j] == id ) { buffer b = alloc_buffer("Error, same field ids for : "); buffer_append(b,fields[i].name); buffer_append(b,":"); val_buffer(b,alloc_int(i)); buffer_append(b," and "); buffer_append(b,fields[j].name); buffer_append(b,":"); val_buffer(b,alloc_int(j)); buffer_append(b,"."); bfailure(b); } } res->fields_ids[i] = id; res->fields_convs[i] = convert_type(fields[i].type,fields[i].flags,fields[i].length); } val_gc(o,free_result); return o; }
static buffer * store_packet_to_buffer( const char *filename ) { assert( filename != NULL ); FILE *fp = fopen( filename, "r" ); if ( fp == NULL ) { // "Can't open a file of test data." return NULL; } // Skip if ( fseek( fp, sizeof( struct pcap_file_header ) + sizeof( uint32_t ) * 2, SEEK_CUR ) != 0 ) { fclose( fp ); return NULL; } uint32_t length[ 2 ]; size_t size = fread( &length, 1, sizeof( length ), fp ); if ( size < sizeof( length ) ) { fclose( fp ); return NULL; } buffer *buffer = alloc_buffer(); if ( buffer == NULL ) { fclose( fp ); return NULL; } size = fread( append_back_buffer( buffer, length[ 0 ] ), 1, length[ 0 ], fp ); if ( size < buffer->length ) { free_buffer( buffer ); fclose( fp ); return NULL; } fclose( fp ); return buffer; }
int hash_init(int power) { size_t bytes; int ret = 0; if (power) hashpower = power; bytes = hashsize(hashpower) * sizeof(void *); ret = alloc_buffer(&primary_hts, bytes, __GFP_ZERO); if (ret) { PRINTK("alloc primary_hashtable error\n"); goto out; } else { BUFFER_PTR(&primary_hts, primary_hashtable); } ATOMIC32_SET(stats.hash_power_level, hashpower); ATOMIC64_SET(stats.hash_bytes, bytes); out: return ret; }
/***********************************************************************//** * @brief Save table column into FITS file * * The table column is only saved if it is linked to a FITS file and if the * data are indeed present in the class instance. This avoids saving of data * that have not been modified. * * Refer to GFitsTableCol::save_column() for more information. ***************************************************************************/ void GFitsTableBoolCol::save(void) { // Free buffer free_buffer(); // Allocate buffer alloc_buffer(); // Transfer string into buffer for (int i = 0; i < m_size; ++i) { m_buffer[i] = (char)m_data[i]; } // Save column save_column(); // Free buffer free_buffer(); // Return return; }
void *nb_alloc (netbuffer_t *H, int len) { netbuffer_t *X, *Y; int s, t; void *res; if (!H || len < 0 || len > NETBUFF_DATA_SIZE) { return 0; } assert (H->state == NB_MAGIC_HEAD || H->state == NB_MAGIC_BUSYHEAD); assert (!H->pptr); X = H->prev; t = -((long) X->wptr) & 3; s = X->end - X->wptr; if (len + t <= s) { res = X->wptr += t; X->wptr += len; H->total_bytes += len; return res; } Y = alloc_buffer(); if (!Y) { return 0; } X->next = Y; Y->prev = X; Y->next = H; H->prev = Y; H->extra++; s = Y->end - Y->wptr; if (len <= s) { res = Y->wptr; Y->wptr += len; H->total_bytes += len; return res; } return 0; }
static value loader_loadmodule( value mname, value vthis ) { value o = val_this(); value cache; val_check(o,object); val_check(mname,string); val_check(vthis,object); cache = val_field(o,id_cache); val_check(cache,object); { reader r; readp p; neko_module *m; neko_vm *vm = NEKO_VM(); field mid = val_id(val_string(mname)); value mv = val_field(cache,mid); if( val_is_kind(mv,neko_kind_module) ) { m = (neko_module*)val_data(mv); return m->exports; } open_module(val_field(o,id_path),val_string(mname),&r,&p); if( vm->fstats ) vm->fstats(vm,"neko_read_module",1); m = neko_read_module(r,p,vthis); if( vm->fstats ) vm->fstats(vm,"neko_read_module",0); close_module(p); if( m == NULL ) { buffer b = alloc_buffer("Invalid module : "); val_buffer(b,mname); bfailure(b); } m->name = alloc_string(val_string(mname)); mv = alloc_abstract(neko_kind_module,m); alloc_field(cache,mid,mv); if( vm->fstats ) vm->fstats(vm,val_string(mname),1); neko_vm_execute(neko_vm_current(),m); if( vm->fstats ) vm->fstats(vm,val_string(mname),0); return m->exports; } }
/** socket_read : 'socket -> string <doc>Read the whole content of a the data available from a socket until the connection close. If the socket hasn't been close by the other side, the function might block. </doc> **/ static value socket_read( value o ) { buffer b; char buf[256]; int len; SOCKET sock = val_sock(o); b = alloc_buffer(NULL); gc_enter_blocking(); while( true ) { POSIX_LABEL(read_again); len = recv(sock,buf,256,MSG_NOSIGNAL); if( len == SOCKET_ERROR ) { HANDLE_EINTR(read_again); return block_error(); } if( len == 0 ) break; gc_exit_blocking(); buffer_append_sub(b,buf,len); gc_enter_blocking(); } gc_exit_blocking(); return buffer_val(b); }
int thread_add(int wfd, int rfd) { static int i = 0; if (i >= wet->evno) { log("thread add error, out of bouder\n"); return -1; } event_set(&(wet->ev[i].e), wfd, EV_WRITE | EV_PERSIST, event_handler, (void*)&(wet->ev[i])); event_base_set(wet->base, &(wet->ev[i].e)); event_add(&(wet->ev[i].e), 0); alloc_buffer(&wet->ev[i].buffer, 4096); wet->ev[i].fd = wfd; struct fdev_t* evs = ret->evs; event_set(&evs[i].ev, rfd, EV_READ | EV_PERSIST, revent_handler, (void*)&evs[i]); event_base_set(ret->base, &evs[i].ev); event_add(&evs[i].ev, 0); create_stream(&evs[i].stream, 4096); evs[i].stream.fd = rfd; ++i; return 0; }
HeapWord* G1ParGCAllocator::allocate_slow(GCAllocPurpose purpose, size_t word_sz, AllocationContext_t context) { HeapWord* obj = NULL; size_t gclab_word_size = _g1h->desired_plab_sz(purpose); if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) { G1ParGCAllocBuffer* alloc_buf = alloc_buffer(purpose, context); add_to_alloc_buffer_waste(alloc_buf->words_remaining()); alloc_buf->retire(false /* end_of_gc */, false /* retain */); HeapWord* buf = _g1h->par_allocate_during_gc(purpose, gclab_word_size, context); if (buf == NULL) { return NULL; // Let caller handle allocation failure. } // Otherwise. alloc_buf->set_word_size(gclab_word_size); alloc_buf->set_buf(buf); obj = alloc_buf->allocate(word_sz); assert(obj != NULL, "buffer was definitely big enough..."); } else { obj = _g1h->par_allocate_during_gc(purpose, word_sz, context); } return obj; }
static int decode_atom(ei_x_buff *eip, int *index, const char *cmp) { int err; int size; int ret; char *buf; buf = alloc_buffer(eip, index, &size); err = ei_decode_atom(eip->buff, index, buf); if (err != 0) { msg_warn("cannot decode atom"); return err; } buf[size-1] = '\0'; ret = strcmp(buf, cmp); if (ret != 0) msg_warn("bad atom: %s", buf); myfree(buf); return ret; }
int main ( int argc, char** argv ) { FILE* fh; byte_t* buf; size_t flen; class_t cls; flags_t flags; if ( get_options ( argc, argv, &flags ) ) return 1; if ( ! ( buf = alloc_buffer ( ) ) ) return 1; if ( ! ( fh = open_input_file ( argv [ argc - 1 ] ) ) ) return 1; if ( ! ( flen = load_file ( buf, fh ) ) ) return 1; if ( classify_image ( &cls, buf, flen ) ) return 1; if ( flags.action == ACTION_CONVERT ) return action_convert ( &cls, buf, flen, argv [ argc - 1 ] ); else return action_print ( &cls ); }
HeapWord* G1PLABAllocator::allocate_direct_or_new_plab(InCSetState dest, size_t word_sz, AllocationContext_t context) { size_t gclab_word_size = _g1h->desired_plab_sz(dest); if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) { G1PLAB* alloc_buf = alloc_buffer(dest, context); alloc_buf->retire(); HeapWord* buf = _allocator->par_allocate_during_gc(dest, gclab_word_size, context); if (buf == NULL) { return NULL; // Let caller handle allocation failure. } // Otherwise. alloc_buf->set_word_size(gclab_word_size); alloc_buf->set_buf(buf); HeapWord* const obj = alloc_buf->allocate(word_sz); assert(obj != NULL, "buffer was definitely big enough..."); return obj; } else { return _allocator->par_allocate_during_gc(dest, word_sz, context); } }
static value do_replace( value o, value s, value s2, bool all ) { val_check_kind(o,k_regexp); val_check(s,string); val_check(s2,string); { pcredata *d = PCRE(o); buffer b = alloc_buffer(NULL); int pos = 0; int len = val_strlen(s); const char *str = val_string(s); const char *str2 = val_string(s2); int len2 = val_strlen(s2); while( pcre_exec(d->r,NULL,str,len,pos,0,d->matchs,d->nmatchs * 3) >= 0 ) { buffer_append_sub(b,str+pos,d->matchs[0] - pos); buffer_append_sub(b,str2,len2); pos = d->matchs[1]; if( !all ) break; } d->str = alloc_null(); buffer_append_sub(b,str+pos,len-pos); return buffer_to_string(b); } }
int add_dir_entry(struct inode *dir, char *name, int len, vfs_ino_t ino) { unsigned int block; vfs_blkno_t blk; struct buf *buf; char *p; struct dentry *de; struct dentry *newde; int minlen; if (len <= 0 || len >= MAXPATH) return -1; if (!VFS_S_ISDIR(dir->desc->mode)) return -1; for (block = 0; block < dir->desc->blocks; block++) { blk = get_inode_block(dir, block); buf = get_buffer(dir->fs->cache, blk); if (!buf) return -1; p = buf->data; while (p < buf->data + dir->fs->blocksize) { de = (struct dentry *) p; minlen = sizeof(struct dentry) + NAME_ALIGN_LEN(de->namelen); if (de->reclen >= minlen + sizeof(struct dentry) + NAME_ALIGN_LEN(de->namelen)) { newde = (struct dentry *) (p + minlen); newde->ino = ino; newde->reclen = de->reclen - minlen; newde->namelen = len; memcpy(newde->name, name, len); de->reclen = minlen; mark_buffer_updated(buf); release_buffer(dir->fs->cache, buf); dir->desc->mtime = time(NULL); mark_inode_dirty(dir); return 0; } p += de->reclen; } release_buffer(dir->fs->cache, buf); } blk = expand_inode(dir); if (blk == -1) return -1; buf = alloc_buffer(dir->fs->cache, blk); if (!buf) return -1; dir->desc->size += dir->fs->blocksize; dir->desc->mtime = time(NULL); mark_inode_dirty(dir); newde = (struct dentry *) (buf->data); newde->ino = ino; newde->reclen = dir->fs->blocksize; newde->namelen = len; memcpy(newde->name, name, len); mark_buffer_updated(buf); release_buffer(dir->fs->cache, buf); return 0; }
/** * 加载配置文件 */ void init_conf(){ buffer_t *rbuf=alloc_buffer(CONF_READ_BUF); int fd=open_conf_file(); enum PARSE_STATE status=RAW; config_module_t *current_module; command_t *current_command; char_t *module_name=init_char(); char_t *command_key=init_char(); char_t *command_value=init_char(); while(1){ if(has_space(rbuf)){ intptr_t count=read(fd,rbuf->data+rbuf->limit,rbuf->size-rbuf->limit); if(count<=0){ goto CONFIG_END; } rbuf->limit+=count; } while(has_remaining(rbuf)){ char c=*(rbuf->data+rbuf->current); rbuf->current+=1; if(status==RAW&&c==brace_start){ status=MODULE_START; }else if(status==MODULE_START&&!char_is_special(c)){ if(c==brace_start){ add_terminal(module_name); current_module=find_config_module(module_name); if(current_module==NULL){ my_log(ERROR,"config error,please check\n"); goto CONFIG_END; }else{ status=FIND_COMMAND_KEY; } }else if(c==brace_end){ goto CONFIG_END; }else{ add_char(module_name,c); } }else if(status==FIND_COMMAND_KEY&&!char_is_special(c)){ if(c==brace_end){ current_module=NULL; reset_char(module_name); status=MODULE_START; }else{ add_char(command_key,c); status=COMMAND_KEY_START; } }else if(status==COMMAND_KEY_START){ if(!char_is_special(c)){ add_char(command_key,c); }else{ add_terminal(command_key); current_command=find_config_command(command_key,current_module); if(current_command==NULL){ my_log(ERROR,"config error,please check\n"); goto CONFIG_END; } status=COMMAND_VALUE_START; } }else if(status==COMMAND_VALUE_START&&!char_is_special(c)){ if(c!=semicolon){ add_char(command_value,c); }else{ add_terminal(command_value); current_command->set_value(command_value); current_command=NULL; reset_char(command_value); reset_char(command_key); status=FIND_COMMAND_KEY; } } } } CONFIG_END: destroy_buffer(rbuf); }
struct filsys *create_filesystem(vfs_devno_t devno, int blocksize, int inode_ratio, int quick) { struct filsys *fs; unsigned int blocks; unsigned int first_block; struct groupdesc *gd; struct buf *buf; unsigned int i, j; vfs_ino_t ino; struct inode *root; char *buffer; // Allocate file system fs = (struct filsys *) malloc(sizeof(struct filsys)); memset(fs, 0, sizeof(struct filsys)); // Allocate super block fs->super = (struct superblock *) malloc(SECTORSIZE); memset(fs->super, 0, SECTORSIZE); fs->super_dirty = 1; // Set device number and block size fs->devno = devno; fs->blocksize = blocksize; // Initialize buffer cache fs->cache = init_buffer_pool(devno, CACHEBUFFERS, fs->blocksize); // Set signature, version and block size in super block fs->super->signature = DFS_SIGNATURE; fs->super->version = DFS_VERSION; fs->super->log_block_size = bits(blocksize); // Each group has as many blocks as can be represented by the block bitmap block fs->super->blocks_per_group = fs->blocksize * 8; // Get the device size in sectors from the device and convert it to blocks fs->super->block_count = dev_getsize(fs->devno) / (fs->blocksize / SECTORSIZE); // Set cache size fs->super->cache_buffers = CACHEBUFFERS; if (fs->super->cache_buffers > fs->super->block_count) fs->super->cache_buffers = 64; // The number of inodes in a group is computed as a ratio of the size of group fs->inodes_per_block = fs->blocksize / sizeof(struct inodedesc); if (fs->super->blocks_per_group < fs->super->block_count) fs->super->inodes_per_group = fs->blocksize * fs->super->blocks_per_group / inode_ratio; else fs->super->inodes_per_group = fs->blocksize * fs->super->block_count / inode_ratio; if (fs->super->inodes_per_group > fs->blocksize * 8) fs->super->inodes_per_group = fs->blocksize * 8; fs->inode_blocks_per_group = (fs->super->inodes_per_group * sizeof(struct inodedesc) + fs->blocksize - 1) / fs->blocksize; // Calculate the number of block pointers per block directory page fs->log_blkptrs_per_block = fs->super->log_block_size - 2; // Calculate the number of group descriptors and the number of blocks to store them fs->super->group_count = (fs->super->block_count + fs->super->blocks_per_group - 1) / fs->super->blocks_per_group; fs->groupdescs_per_block = fs->blocksize / sizeof(struct groupdesc); fs->groupdesc_blocks = (fs->super->group_count * sizeof(struct groupdesc) + fs->blocksize - 1) / fs->blocksize; // The reserved blocks are allocated right after the super block fs->super->first_reserved_block = 1; if (fs->blocksize <= SECTORSIZE) fs->super->first_reserved_block++; fs->super->reserved_blocks = RESERVED_BLOCKS; // The group descriptor table starts after the superblock and reserved blocks fs->super->groupdesc_table_block = fs->super->first_reserved_block + fs->super->reserved_blocks; // If the last group is too small to hold the bitmaps and inode table skip it blocks = fs->super->block_count % fs->super->blocks_per_group; if (blocks > 0 && blocks < fs->inode_blocks_per_group + 2) fs->super->group_count--; if (fs->super->group_count == 0) panic("filesystem too small"); // Zero all blocks on disk if (!quick) { buffer = (char *) malloc(fs->blocksize); memset(buffer, 0, fs->blocksize); for (i = fs->super->groupdesc_table_block + fs->groupdesc_blocks; i < fs->super->block_count; i++) { dev_write(fs->devno, buffer, fs->blocksize, i); } free(buffer); } // Allocate group descriptors fs->groupdesc_buffers = (struct buf **) malloc(sizeof(struct buf *) * fs->groupdesc_blocks); fs->groups = (struct group *) malloc(sizeof(struct group) * fs->super->group_count); for (i = 0; i < fs->groupdesc_blocks; i++) { fs->groupdesc_buffers[i] = alloc_buffer(fs->cache, fs->super->groupdesc_table_block + i); } for (i = 0; i < fs->super->group_count; i++) { gd = (struct groupdesc *) fs->groupdesc_buffers[i / fs->groupdescs_per_block]->data; gd += (i % fs->groupdescs_per_block); fs->groups[i].desc = gd; fs->groups[i].first_free_block = 0; fs->groups[i].first_free_inode = 0; } // Reserve inode for root directory fs->super->reserved_inodes = RESERVED_INODES; // Set inode count based on group count fs->super->inode_count = fs->super->inodes_per_group * fs->super->group_count; // All blocks and inodes initially free fs->super->free_inode_count = fs->super->inode_count; fs->super->free_block_count = fs->super->block_count; // Initialize block bitmaps for (i = 0; i < fs->super->group_count; i++) { gd = fs->groups[i].desc; blocks = 0; first_block = fs->super->blocks_per_group * i; // The first group needs blocks for the super block and the group descriptors if (i == 0) blocks = fs->super->groupdesc_table_block + fs->groupdesc_blocks; // Next blocks in group are the block bitmap, inode bitmap and the inode table gd->block_bitmap_block = first_block + blocks++; gd->inode_bitmap_block = first_block + blocks++; gd->inode_table_block = first_block + blocks; blocks += fs->inode_blocks_per_group; // Update block bitmap buf = alloc_buffer(fs->cache, gd->block_bitmap_block); set_bits(buf->data, 0, blocks); mark_buffer_updated(buf); release_buffer(fs->cache, buf); // Determine the block count for the group. The last group may be truncated if (fs->super->blocks_per_group * (i + 1) > fs->super->block_count) gd->block_count = fs->super->block_count - fs->super->blocks_per_group * i; else gd->block_count = fs->super->blocks_per_group; // Set the count of free blocks and inodes for group gd->free_inode_count = fs->super->inodes_per_group; gd->free_block_count = gd->block_count - blocks; // Update super block fs->super->free_block_count -= blocks; mark_group_desc_dirty(fs, i); } // Zero out block and inode bitmaps and inode tables if (quick) { buffer = (char *) malloc(fs->blocksize); memset(buffer, 0, fs->blocksize); for (i = 0; i < fs->super->group_count; i++) { gd = fs->groups[i].desc; dev_write(fs->devno, buffer, fs->blocksize, gd->block_bitmap_block); dev_write(fs->devno, buffer, fs->blocksize, gd->inode_bitmap_block); for (j = 0; j < fs->inode_blocks_per_group; j++) { dev_write(fs->devno, buffer, fs->blocksize, gd->inode_table_block + j); } } free(buffer); } // Reserve inodes for (i = 0; i < RESERVED_INODES; i++) { ino = new_inode(fs, 0, 0); if (ino != i) panic("unexpected inode"); } // Create root directory root = get_inode(fs, DFS_INODE_ROOT); root->desc->mode = VFS_S_IFDIR | VFS_S_IRWXU | VFS_S_IRWXG | VFS_S_IRWXO; root->desc->ctime = root->desc->mtime = time(NULL); root->desc->linkcount = 1; mark_buffer_updated(root->buf); release_inode(root); return fs; }
void G1PLABAllocator::undo_allocation(InCSetState dest, HeapWord* obj, size_t word_sz, AllocationContext_t context) { alloc_buffer(dest, context)->undo_allocation(obj, word_sz); }
/** process_run : cmd:string -> args:string array -> 'process <doc> Start a process using a command and the specified arguments. When args is not null, cmd and args will be auto-quoted/escaped. If no auto-quoting/escaping is desired, you should append necessary arguments to cmd as if it is inputted to the shell directly, and pass null as args. </doc> **/ static value process_run( value cmd, value vargs ) { int i, isRaw; vprocess *p; val_check(cmd,string); isRaw = val_is_null(vargs); if (!isRaw) { val_check(vargs,array); } # ifdef NEKO_WINDOWS { SECURITY_ATTRIBUTES sattr; STARTUPINFO sinf; HANDLE proc = GetCurrentProcess(); HANDLE oread,eread,iwrite; // creates commandline buffer b = alloc_buffer(NULL); value sargs; if (isRaw) { char* cmdexe = getenv("COMSPEC"); if (!cmdexe) cmdexe = "cmd.exe"; buffer_append(b,"\""); buffer_append(b,cmdexe); buffer_append(b,"\" /C \""); buffer_append(b,val_string(cmd)); buffer_append_char(b,'"'); } else { buffer_append_char(b,'"'); val_buffer(b,cmd); buffer_append_char(b,'"'); for(i=0;i<val_array_size(vargs);i++) { value v = val_array_ptr(vargs)[i]; int j,len; unsigned int bs_count = 0; unsigned int k; val_check(v,string); len = val_strlen(v); buffer_append(b," \""); for(j=0;j<len;j++) { char c = val_string(v)[j]; switch( c ) { case '"': // Double backslashes. for (k=0;k<bs_count*2;k++) { buffer_append_char(b,'\\'); } bs_count = 0; buffer_append(b, "\\\""); break; case '\\': // Don't know if we need to double yet. bs_count++; break; default: // Normal char for (k=0;k<bs_count;k++) { buffer_append_char(b,'\\'); } bs_count = 0; buffer_append_char(b,c); break; } } // Add remaining backslashes, if any. for (k=0;k<bs_count*2;k++) { buffer_append_char(b,'\\'); } buffer_append_char(b,'"'); } } sargs = buffer_to_string(b); p = (vprocess*)alloc_private(sizeof(vprocess)); // startup process sattr.nLength = sizeof(sattr); sattr.bInheritHandle = TRUE; sattr.lpSecurityDescriptor = NULL; memset(&sinf,0,sizeof(sinf)); sinf.cb = sizeof(sinf); sinf.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW; sinf.wShowWindow = SW_HIDE; CreatePipe(&oread,&sinf.hStdOutput,&sattr,0); CreatePipe(&eread,&sinf.hStdError,&sattr,0); CreatePipe(&sinf.hStdInput,&iwrite,&sattr,0); DuplicateHandle(proc,oread,proc,&p->oread,0,FALSE,DUPLICATE_SAME_ACCESS); DuplicateHandle(proc,eread,proc,&p->eread,0,FALSE,DUPLICATE_SAME_ACCESS); DuplicateHandle(proc,iwrite,proc,&p->iwrite,0,FALSE,DUPLICATE_SAME_ACCESS); CloseHandle(oread); CloseHandle(eread); CloseHandle(iwrite); if( !CreateProcess(NULL,val_string(sargs),NULL,NULL,TRUE,0,NULL,NULL,&sinf,&p->pinf) ) neko_error(); // close unused pipes CloseHandle(sinf.hStdOutput); CloseHandle(sinf.hStdError); CloseHandle(sinf.hStdInput); } # else char **argv; if (isRaw) { argv = (char**)alloc_private(sizeof(char*)*4); argv[0] = "/bin/sh"; argv[1] = "-c"; argv[2] = val_string(cmd); argv[3] = NULL; } else { argv = (char**)alloc_private(sizeof(char*)*(val_array_size(vargs)+2)); argv[0] = val_string(cmd); for(i=0;i<val_array_size(vargs);i++) { value v = val_array_ptr(vargs)[i]; val_check(v,string); argv[i+1] = val_string(v); } argv[i+1] = NULL; } int input[2], output[2], error[2]; if( pipe(input) || pipe(output) || pipe(error) ) neko_error(); p = (vprocess*)alloc_private(sizeof(vprocess)); p->pid = fork(); if( p->pid == -1 ) { do_close(input[0]); do_close(input[1]); do_close(output[0]); do_close(output[1]); do_close(error[0]); do_close(error[1]); neko_error(); } // child if( p->pid == 0 ) { close(input[1]); close(output[0]); close(error[0]); dup2(input[0],0); dup2(output[1],1); dup2(error[1],2); execvp(argv[0],argv); fprintf(stderr,"Command not found : %s\n",val_string(cmd)); exit(1); } // parent do_close(input[0]); do_close(output[1]); do_close(error[1]); p->iwrite = input[1]; p->oread = output[0]; p->eread = error[0]; # endif { value vp = alloc_abstract(k_process,p); val_gc(vp,free_process); return vp; } }