Exemplo n.º 1
0
void checkIntegrity(void)
{
	struct chunkHeader *walker;
	struct chunkTrailer *chunkTrailer;
	unsigned char *memory;

//        dbgf_all(DBGT_INFO, " ");

	for (walker = chunkList; walker != NULL; walker = walker->next)
	{
		if (walker->magicNumber != MAGIC_NUMBER)
		{
			dbgf( DBGL_SYS, DBGT_ERR, 
			     "invalid magic number in header: %08x, malloc tag = %d", 
			     walker->magicNumber, walker->tag );
			cleanup_all( -500073 );
		}

		memory = (unsigned char *)walker;

		chunkTrailer = (struct chunkTrailer *)(memory + sizeof(struct chunkHeader) + walker->length);

		if (chunkTrailer->magicNumber != MAGIC_NUMBER)
		{
			dbgf( DBGL_SYS, DBGT_ERR, 
			     "invalid magic number in trailer: %08x, malloc tag = %d", 
			     chunkTrailer->magicNumber, walker->tag );
			cleanup_all( -500075 );
		}
	}

}
Exemplo n.º 2
0
void removeMemory(int32_t tag, int32_t freetag)
{

	struct memoryUsage *walker;

	for ( walker = memoryList; walker != NULL; walker = walker->next ) {

		if ( walker->tag == tag ) {

			if ( walker->counter == 0 ) {

				dbg( DBGL_SYS, DBGT_ERR, 
				     "Freeing more memory than was allocated: malloc tag = %d, free tag = %d", 
				     tag, freetag );
				cleanup_all( -500069 );

			}

			walker->counter--;
			break;

		}

	}

	if ( walker == NULL ) {

		dbg( DBGL_SYS, DBGT_ERR, 
		     "Freeing memory that was never allocated: malloc tag = %d, free tag = %d",
		     tag, freetag );
		cleanup_all( -500070 );
	}
}
Exemplo n.º 3
0
int main( int argc, char *argv[] )
{
	struct map_data *map;
	if ( init(&map, argc, argv) ) {
		exit( 0 );
	}
	
	int cur = '\0';
	
	point_t start = get_start_point( map );
	

	
	 do {
		clear();
		print_map( map );
		
		process_key( cur );
		switch ( cur ) {
			default: {
				point_t target = get_cursor();
				//mvprintw( 0, 0, "Cursor was at : (%d, %d)", target.x, target.y);
				path_t *path_to_target = search_path( start, target, map );
				print_path( path_to_target );
				refresh();
			}
		}
		
		refresh();
	 } while ( (cur = getch()) != 'q' );
	
	
	cleanup_all();
	return 0;
}
Exemplo n.º 4
0
/**
 * Create the Timer Task
 * @param _init_callback
 */
void StartTimerLoop(CO_Data* d, TimerCallback_t _init_callback)
{
	int ret = 0;
	stop_timer = 0;
	init_callback = _init_callback;
	callback_od = d;

	char taskname[32];
	snprintf(taskname, sizeof(taskname), "timerloop-%d", current->pid);

	/* create timerloop_task */
	ret = rt_task_create(&timerloop_task, taskname, 0, 50, 0); /* T_JOINABLE only in user space */
	if (ret) {
		printk("Failed to create timerloop_task, code %d\n",ret);
		return;
	}

	/* start timerloop_task */
	ret = rt_task_start(&timerloop_task,&timerloop_task_proc,NULL);
	if (ret) {
		printk("Failed to start timerloop_task, code %u\n",ret);
		goto error;
	}

	return;

error:
	cleanup_all();
}
Exemplo n.º 5
0
static void process_signal(int sig){
	int r = 0;

	switch(sig) {
	case SIGINT:
	case SIGQUIT:
	case SIGTERM:
	case SIGHUP:
		r += log_status();
		break;
	case SIGUSR1:
	case SIGUSR2:
		log_debug();
		/*local_debug();*/
		cluster_debug();
		return;
	default:
		LOG_PRINT("Unknown signal received... ignoring");
		return;
	}

	if (!r) {
		LOG_DBG("No current cluster logs... safe to exit.");
		cleanup_all();
		exit(EXIT_SUCCESS);
	}

	LOG_ERROR("Cluster logs exist.  Refusing to exit.");
}
Exemplo n.º 6
0
/* Ensures we can read a certain amount of bytes without overrunning the end
 * of the stream. */
static void ensure_can_read(MVMThreadContext *tc, MVMCompUnit *cu, ReaderState *rs, MVMuint8 *pos, MVMuint32 size) {
    MVMCompUnitBody *cu_body = &cu->body;
    if (pos + size > cu_body->data_start + cu_body->data_size) {
        if (rs)
            cleanup_all(tc, rs);
        MVM_exception_throw_adhoc(tc, "Read past end of bytecode stream");
    }
}
Exemplo n.º 7
0
void *_debugRealloc(void *memoryParameter, uint32_t length, int32_t tag)
{
	
	unsigned char *memory;
	struct chunkHeader *chunkHeader=NULL;
	struct chunkTrailer *chunkTrailer;
	unsigned char *result;
	uint32_t copyLength;

	if (memoryParameter) { /* if memoryParameter==NULL, realloc() should work like malloc() !! */
		memory = memoryParameter;
		chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader));

		if (chunkHeader->magicNumber != MAGIC_NUMBER)
		{
			dbgf( DBGL_SYS, DBGT_ERR, 
			     "invalid magic number in header: %08x, malloc tag = %d", 
			     chunkHeader->magicNumber, chunkHeader->tag );
			cleanup_all( -500078 );
		}

		chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length);

		if (chunkTrailer->magicNumber != MAGIC_NUMBER)
		{
			dbgf( DBGL_SYS, DBGT_ERR, 
			     "invalid magic number in trailer: %08x, malloc tag = %d", 
			     chunkTrailer->magicNumber, chunkHeader->tag );
			cleanup_all( -500079 );
		}
	}


	result = _debugMalloc(length, tag);
	if (memoryParameter) {
		copyLength = length;

		if (copyLength > chunkHeader->length)
			copyLength = chunkHeader->length;

		memcpy(result, memoryParameter, copyLength);
		debugFree(memoryParameter, -300280);
	}

	return result;
}
Exemplo n.º 8
0
/* Reads a string index, looks up the string and returns it. Bounds
 * checks the string heap index too. */
static MVMString * get_heap_string(MVMThreadContext *tc, MVMCompUnit *cu, ReaderState *rs, MVMuint8 *buffer, size_t offset) {
    MVMuint32 heap_index = read_int32(buffer, offset);
    if (heap_index >= cu->body.num_strings) {
        if (rs)
            cleanup_all(tc, rs);
        MVM_exception_throw_adhoc(tc, "String heap index beyond end of string heap");
    }
    return MVM_cu_string(tc, cu, heap_index);
}
Exemplo n.º 9
0
/* the main program when not doing a compile */
static int ccache_main(int argc, char *argv[])
{
	int c;
	size_t v;

	while ((c = getopt(argc, argv, "hszcCF:M:V")) != -1) {
		switch (c) {
		case 'V':
			printf("ccache version %s\n", CCACHE_VERSION);
			printf("Copyright Andrew Tridgell 2002\n");
			printf("Released under the GNU GPL v2 or later\n");
			exit(0);

		case 'h':
			usage();
			exit(0);
			
		case 's':
			stats_summary();
			break;

		case 'c':
			cleanup_all(cache_dir);
			printf("Cleaned cache\n");
			break;

		case 'C':
			wipe_all(cache_dir);
			printf("Cleared cache\n");
			break;

		case 'z':
			stats_zero();
			printf("Statistics cleared\n");
			break;

		case 'F':
			v = atoi(optarg);
			stats_set_limits(v, -1);
			printf("Set cache file limit to %u\n", (unsigned)v);
			break;

		case 'M':
			v = value_units(optarg);
			stats_set_limits(-1, v);
			printf("Set cache size limit to %uk\n", (unsigned)v);
			break;

		default:
			usage();
			exit(1);
		}
	}

	return 0;
}
Exemplo n.º 10
0
void *_debugRealloc(void *memory, uint32_t length, int32_t tag)
{
	void *result;

	result = realloc(memory, length);

	if (result == NULL) {
		dbg( DBGL_SYS, DBGT_ERR, "Cannot re-allocate %u bytes, malloc tag = %d", length, tag );
		cleanup_all( -500071 );
	}

	return result;
}
Exemplo n.º 11
0
/* Loads the SC dependencies list. */
static void deserialize_sc_deps(MVMThreadContext *tc, MVMCompUnit *cu, ReaderState *rs) {
    MVMCompUnitBody *cu_body = &cu->body;
    MVMuint32 i, sh_idx;
    MVMuint8  *pos;

    /* Allocate SC lists in compilation unit. */
    cu_body->scs = MVM_malloc(rs->expected_scs * sizeof(MVMSerializationContext *));
    cu_body->scs_to_resolve = MVM_malloc(rs->expected_scs * sizeof(MVMSerializationContextBody *));
    cu_body->sc_handle_idxs = MVM_malloc(rs->expected_scs * sizeof(MVMint32));
    cu_body->num_scs = rs->expected_scs;

    /* Resolve all the things. */
    pos = rs->sc_seg;
    for (i = 0; i < rs->expected_scs; i++) {
        MVMSerializationContextBody *scb;
        MVMString *handle;

        /* Grab string heap index. */
        ensure_can_read(tc, cu, rs, pos, 4);
        sh_idx = read_int32(pos, 0);
        pos += 4;

        /* Resolve to string. */
        if (sh_idx >= cu_body->num_strings) {
            cleanup_all(tc, rs);
            MVM_exception_throw_adhoc(tc, "String heap index beyond end of string heap");
        }
        cu_body->sc_handle_idxs[i] = sh_idx;
        handle = MVM_cu_string(tc, cu, sh_idx);

        /* See if we can resolve it. */
        uv_mutex_lock(&tc->instance->mutex_sc_weakhash);
        MVM_string_flatten(tc, handle);
        MVM_HASH_GET(tc, tc->instance->sc_weakhash, handle, scb);
        if (scb && scb->sc) {
            cu_body->scs_to_resolve[i] = NULL;
            MVM_ASSIGN_REF(tc, &(cu->common.header), cu_body->scs[i], scb->sc);
        }
        else {
            if (!scb) {
                scb = MVM_calloc(1, sizeof(MVMSerializationContextBody));
                scb->handle = handle;
                MVM_HASH_BIND(tc, tc->instance->sc_weakhash, handle, scb);
                MVM_sc_add_all_scs_entry(tc, scb);
            }
            cu_body->scs_to_resolve[i] = scb;
            cu_body->scs[i] = NULL;
        }
        uv_mutex_unlock(&tc->instance->mutex_sc_weakhash);
    }
}
Exemplo n.º 12
0
/* wipe all cached files in all subdirs */
void wipe_all(struct conf *conf)
{
	char *dname;
	int i;

	for (i = 0; i <= 0xF; i++) {
		dname = format("%s/%1x", conf->cache_dir, i);
		traverse(dname, wipe_fn);
		free(dname);
	}

	/* and fix the counters */
	cleanup_all(conf);
}
Exemplo n.º 13
0
/* wipe all cached files in all subdirs */
void wipe_all(const char *dir)
{
	char *dname;
	int i;

	for (i = 0; i <= 0xF; i++) {
		dname = format("%s/%1x", dir, i);
		traverse(dir, wipe_fn);
		free(dname);
	}

	/* and fix the counters */
	cleanup_all(dir);
}
Exemplo n.º 14
0
void *_debugMalloc(uint32_t length, int32_t tag)
{
	void *result;

	result = malloc(length);

	if (result == NULL)
	{
		dbg( DBGL_SYS, DBGT_ERR, "Cannot allocate %u bytes, malloc tag = %d", length, tag );
		cleanup_all( -500072 );
	}

	return result;
}
Exemplo n.º 15
0
Arquivo: sms.c Projeto: agustim/bmx6
STATIC_FUNC
void json_inotify_event_hook(int fd)
{
        TRACE_FUNCTION_CALL;

        dbgf_track(DBGT_INFO, "detected changes in directory: %s", smsTx_dir);

        assertion(-501278, (fd > -1 && fd == extensions_fd));

        int ilen = 1024;
        char *ibuff = debugMalloc(ilen, -300375);
        int rcvd;
        int processed = 0;

        while ((rcvd = read(fd, ibuff, ilen)) == 0 || rcvd == EINVAL) {

                ibuff = debugRealloc(ibuff, (ilen = ilen * 2), -300376);
                assertion(-501279, (ilen <= (1024 * 16)));
        }

        if (rcvd > 0) {

                while (processed < rcvd) {

                        struct inotify_event *ievent = (struct inotify_event *) &ibuff[processed];

                        processed += (sizeof (struct inotify_event) +ievent->len);

                        if (ievent->mask & (IN_DELETE_SELF)) {
                                dbgf_sys(DBGT_ERR, "directory %s has been removed \n", smsTx_dir);
                                cleanup_all(-501290);
                        }
                }

        } else {
                dbgf_sys(DBGT_ERR, "read()=%d: %s \n", rcvd, strerror(errno));
        }

        debugFree(ibuff, -300377);

        check_for_changed_sms(NULL);
}
Exemplo n.º 16
0
void *_debugMalloc(uint32_t length, int32_t tag) {
	
	unsigned char *memory;
	struct chunkHeader *chunkHeader;
	struct chunkTrailer *chunkTrailer;
	unsigned char *chunk;

	memory = malloc(length + sizeof(struct chunkHeader) + sizeof(struct chunkTrailer));

	if (memory == NULL)
	{
		dbg( DBGL_SYS, DBGT_ERR, "Cannot allocate %u bytes, malloc tag = %d", 
		     (unsigned int)(length + sizeof(struct chunkHeader) + sizeof(struct chunkTrailer)), tag );
		cleanup_all( -500076 );
	}

	chunkHeader = (struct chunkHeader *)memory;
	chunk = memory + sizeof(struct chunkHeader);
	chunkTrailer = (struct chunkTrailer *)(memory + sizeof(struct chunkHeader) + length);

	chunkHeader->length = length;
	chunkHeader->tag = tag;
	chunkHeader->magicNumber = MAGIC_NUMBER;

	chunkTrailer->magicNumber = MAGIC_NUMBER;

	chunkHeader->next = chunkList;
	chunkList = chunkHeader;

#ifdef MEMORY_USAGE

	addMemory( length, tag );

#endif

	return chunk;
}
Exemplo n.º 17
0
/* Dissects the bytecode stream and hands back a reader pointing to the
 * various parts of it. */
static ReaderState * dissect_bytecode(MVMThreadContext *tc, MVMCompUnit *cu) {
    MVMCompUnitBody *cu_body = &cu->body;
    ReaderState *rs = NULL;
    MVMuint32 version, offset, size;

    /* Sanity checks. */
    if (cu_body->data_size < HEADER_SIZE)
        MVM_exception_throw_adhoc(tc, "Bytecode stream shorter than header");
    if (memcmp(cu_body->data_start, "MOARVM\r\n", 8) != 0)
        MVM_exception_throw_adhoc(tc, "Bytecode stream corrupt (missing magic string)");
    version = read_int32(cu_body->data_start, 8);
    if (version < MIN_BYTECODE_VERSION)
        MVM_exception_throw_adhoc(tc, "Bytecode stream version too low");
    if (version > MAX_BYTECODE_VERSION)
        MVM_exception_throw_adhoc(tc, "Bytecode stream version too high");

    /* Allocate reader state. */
    rs = MVM_malloc(sizeof(ReaderState));
    memset(rs, 0, sizeof(ReaderState));
    rs->version = version;
    rs->read_limit = cu_body->data_start + cu_body->data_size;
    cu->body.bytecode_version = version;

    /* Locate SC dependencies segment. */
    offset = read_int32(cu_body->data_start, SCDEP_HEADER_OFFSET);
    if (offset > cu_body->data_size) {
        cleanup_all(tc, rs);
        MVM_exception_throw_adhoc(tc, "Serialization contexts segment starts after end of stream");
    }
    rs->sc_seg       = cu_body->data_start + offset;
    rs->expected_scs = read_int32(cu_body->data_start, SCDEP_HEADER_OFFSET + 4);

    /* Locate extension ops segment. */
    offset = read_int32(cu_body->data_start, EXTOP_HEADER_OFFSET);
    if (offset > cu_body->data_size) {
        cleanup_all(tc, rs);
        MVM_exception_throw_adhoc(tc, "Extension ops segment starts after end of stream");
    }
    rs->extop_seg       = cu_body->data_start + offset;
    rs->expected_extops = read_int32(cu_body->data_start, EXTOP_HEADER_OFFSET + 4);

    /* Locate frames segment. */
    offset = read_int32(cu_body->data_start, FRAME_HEADER_OFFSET);
    if (offset > cu_body->data_size) {
        cleanup_all(tc, rs);
        MVM_exception_throw_adhoc(tc, "Frames segment starts after end of stream");
    }
    rs->frame_seg       = cu_body->data_start + offset;
    rs->expected_frames = read_int32(cu_body->data_start, FRAME_HEADER_OFFSET + 4);

    /* Locate callsites segment. */
    offset = read_int32(cu_body->data_start, CALLSITE_HEADER_OFFSET);
    if (offset > cu_body->data_size) {
        cleanup_all(tc, rs);
        MVM_exception_throw_adhoc(tc, "Callsites segment starts after end of stream");
    }
    rs->callsite_seg       = cu_body->data_start + offset;
    rs->expected_callsites = read_int32(cu_body->data_start, CALLSITE_HEADER_OFFSET + 4);

    /* Locate strings segment. */
    offset = read_int32(cu_body->data_start, STRING_HEADER_OFFSET);
    if (offset > cu_body->data_size) {
        cleanup_all(tc, rs);
        MVM_exception_throw_adhoc(tc, "Strings segment starts after end of stream");
    }
    rs->string_seg       = cu_body->data_start + offset;
    rs->expected_strings = read_int32(cu_body->data_start, STRING_HEADER_OFFSET + 4);

    /* Get SC data, if any. */
    offset = read_int32(cu_body->data_start, SCDATA_HEADER_OFFSET);
    size = read_int32(cu_body->data_start, SCDATA_HEADER_OFFSET + 4);
    if (offset > cu_body->data_size || offset + size > cu_body->data_size) {
        cleanup_all(tc, rs);
        MVM_exception_throw_adhoc(tc, "Serialized data segment overflows end of stream");
    }
    if (offset) {
        cu_body->serialized = cu_body->data_start + offset;
        cu_body->serialized_size = size;
    }

    /* Locate bytecode segment. */
    offset = read_int32(cu_body->data_start, BYTECODE_HEADER_OFFSET);
    size = read_int32(cu_body->data_start, BYTECODE_HEADER_OFFSET + 4);
    if (offset > cu_body->data_size || offset + size > cu_body->data_size) {
        cleanup_all(tc, rs);
        MVM_exception_throw_adhoc(tc, "Bytecode segment overflows end of stream");
    }
    rs->bytecode_seg  = cu_body->data_start + offset;
    rs->bytecode_size = size;

    /* Locate annotations segment. */
    offset = read_int32(cu_body->data_start, ANNOTATION_HEADER_OFFSET);
    size = read_int32(cu_body->data_start, ANNOTATION_HEADER_OFFSET + 4);
    if (offset > cu_body->data_size || offset + size > cu_body->data_size) {
        cleanup_all(tc, rs);
        MVM_exception_throw_adhoc(tc, "Annotation segment overflows end of stream");
    }
    rs->annotation_seg  = cu_body->data_start + offset;
    rs->annotation_size = size;

    /* Locate HLL name */
    rs->hll_str_idx = read_int32(cu_body->data_start, HLL_NAME_HEADER_OFFSET);

    /* Locate special frame indexes. Note, they are 0 for none, and the
     * index + 1 if there is one. */
    rs->main_frame = read_int32(cu_body->data_start, SPECIAL_FRAME_HEADER_OFFSET);
    rs->load_frame = read_int32(cu_body->data_start, SPECIAL_FRAME_HEADER_OFFSET + 4);
    rs->deserialize_frame = read_int32(cu_body->data_start, SPECIAL_FRAME_HEADER_OFFSET + 8);
    if (rs->main_frame > rs->expected_frames
            || rs->load_frame > rs->expected_frames
            || rs->deserialize_frame > rs->expected_frames) {
        MVM_exception_throw_adhoc(tc, "Special frame index out of bounds");
    }

    return rs;
}
Exemplo n.º 18
0
/* Ensures we can read a certain amount of bytes without overrunning the end
 * of the stream. */
MVM_STATIC_INLINE void ensure_can_read(MVMThreadContext *tc, MVMCompUnit *cu, ReaderState *rs, MVMuint8 *pos, MVMuint32 size) {
    if (pos + size > rs->read_limit) {
        cleanup_all(tc, rs);
        MVM_exception_throw_adhoc(tc, "Read past end of bytecode stream");
    }
}
Exemplo n.º 19
0
static void throw_past_end(MVMThreadContext *tc, MVMuint8 *labels) {
    cleanup_all(tc, labels);
    MVM_exception_throw_adhoc(tc,
                "Bytecode validation error: truncated stream");
}
Exemplo n.º 20
0
/* Validate that a static frame's bytecode is executable by the interpreter */
void MVM_validate_static_frame(MVMThreadContext *tc, MVMStaticFrame *static_frame) {
    
    MVMCompUnit *cu = static_frame->cu;
    MVMuint32 bytecode_size = static_frame->bytecode_size;
    MVMuint8 *bytecode_start = static_frame->bytecode;
    MVMuint8 *bytecode_end = bytecode_start + bytecode_size;
    /* current position in the bytestream */
    MVMuint8 *cur_op = bytecode_start;
    /* positions in the bytestream that are starts of ops and goto targets */
    MVMuint8 *labels = malloc(bytecode_size);
    MVMuint32 num_locals = static_frame->num_locals;
    MVMuint32 branch_target;
    MVMuint8 bank_num;
    MVMuint8 op_num;
    MVMOpInfo *op_info;
    MVMuint32 operand_size;
    MVMuint16 operand_target;
    MVMuint32 instruction = 0;
    MVMuint32 i;
    unsigned char op_rw;
    unsigned char op_type;
    unsigned char op_flags;
    MVMuint32 operand_type_var;
    MVMint64 num_jumplist_labels = 0;
    
    memset(labels, 0, bytecode_size);
    
    /* printf("bytecode_size %d cur_op %d bytecode_end %d difference %d", bytecode_size, (int)cur_op, (int)bytecode_end, (int)(bytecode_end - cur_op)); */
    while (cur_op < bytecode_end - 1) {
        labels[cur_op - bytecode_start] |= MVM_val_op_boundary;
        bank_num = *(cur_op++);
        op_num = *(cur_op++);
        operand_type_var = 0;
        op_info = MVM_op_get_op((unsigned char)bank_num, (unsigned char)op_num);
        if (!op_info) {
            cleanup_all(tc, labels);
            MVM_exception_throw_adhoc(tc,
                "Bytecode validation error: non-existent operation bank %u op %u",
                bank_num, op_num);
        }
        if (num_jumplist_labels != 0 && num_jumplist_labels-- != 0
                && (bank_num != MVM_OP_BANK_primitives || op_num != MVM_OP_goto)) {
            cleanup_all(tc, labels);
            MVM_exception_throw_adhoc(tc,
                "jumplist op must be followed by an additional %d goto ops", num_jumplist_labels + 1);
        }
        /*printf("validating op %s, (%d) bank %d", op_info->name, op_num, bank_num);*/
        for (i = 0; i < op_info->num_operands; i++) {
            op_flags = op_info->operands[i];
            op_rw   = op_flags & MVM_operand_rw_mask;
            op_type = op_flags & MVM_operand_type_mask;
            if (op_rw == MVM_operand_literal) {
                switch (op_type) {
                    case MVM_operand_int8:      operand_size = 1; break;
                    case MVM_operand_int16:     operand_size = 2; break;
                    case MVM_operand_int32:     operand_size = 4; break;
                    case MVM_operand_int64:
                        operand_size = 8;
                        if (bank_num == MVM_OP_BANK_primitives && op_num == MVM_OP_jumplist) {
                            if (cur_op + operand_size > bytecode_end)
                                throw_past_end(tc, labels);
                            num_jumplist_labels = GET_I64(cur_op, 0);
                            if (num_jumplist_labels < 0 || num_jumplist_labels > 4294967295u) {
                                cleanup_all(tc, labels);
                                MVM_exception_throw_adhoc(tc,
                                    "num_jumplist_labels %d out of range", num_jumplist_labels);
                            }
                        }
                        break;
                    case MVM_operand_num32:     operand_size = 4; break;
                    case MVM_operand_num64:     operand_size = 8; break;
                    case MVM_operand_callsite:
                        operand_size = 2;
                        if (cur_op + operand_size > bytecode_end)
                            throw_past_end(tc, labels);
                        operand_target = GET_UI16(cur_op, 0);
                        if (operand_target >= cu->num_callsites) {
                            cleanup_all(tc, labels);
                            MVM_exception_throw_adhoc(tc,
                                "Bytecode validation error: callsites index (%u) out of range; frame has %u callsites",
                                operand_target, cu->num_callsites);
                        }
                        break;
                        
                    case MVM_operand_coderef:
                        operand_size = 2;
                        if (cur_op + operand_size > bytecode_end)
                            throw_past_end(tc, labels);
                        operand_target = GET_UI16(cur_op, 0);
                        if (operand_target >= cu->num_frames) {
                            cleanup_all(tc, labels);
                            MVM_exception_throw_adhoc(tc,
                                "Bytecode validation error: coderef index (%u) out of range; frame has %u coderefs",
                                operand_target, cu->num_frames);
                        }
                        break; /* reset to 0 */
                    
                    case MVM_operand_str:
                        operand_size = 2;
                        if (cur_op + operand_size > bytecode_end)
                            throw_past_end(tc, labels);
                        operand_target = GET_UI16(cur_op, 0);
                        if (operand_target >= cu->num_strings) {
                            cleanup_all(tc, labels);
                            MVM_exception_throw_adhoc(tc,
                                "Bytecode validation error: strings index (%u) out of range (0-%u)",
                                operand_target, cu->num_strings - 1);
                        }
                        break;
                        
                    case MVM_operand_ins:
                        operand_size = 4;
                        if (cur_op + operand_size > bytecode_end)
                            throw_past_end(tc, labels);
                        branch_target = GET_UI32(cur_op, 0);
                        if (branch_target >= bytecode_size) {
                            cleanup_all(tc, labels);
                            MVM_exception_throw_adhoc(tc,
                                "Bytecode validation error: branch instruction offset (%u) out of range; frame has %u bytes",
                                branch_target, bytecode_size);
                        }
                        labels[branch_target] |= MVM_val_branch_target;
                        break;
                    
                    case MVM_operand_obj:
                    case MVM_operand_type_var:
                        cleanup_all(tc, labels);
                        MVM_exception_throw_adhoc(tc,
                            "Bytecode validation error: that operand type (%u) can't be a literal",
                            (MVMuint8)op_type);
                        break;
                    default: {
                        cleanup_all(tc, labels);
                        MVM_exception_throw_adhoc(tc,
                            "Bytecode validation error: non-existent operand type (%u)",
                            (MVMuint8)op_type);
                    }
                }
                if (cur_op + operand_size > bytecode_end)
                    throw_past_end(tc, labels);
            }
            else if (op_rw == MVM_operand_read_reg || op_rw == MVM_operand_write_reg) {
                /* register operand */
                operand_size = 2;
                if (cur_op + operand_size > bytecode_end)
                    throw_past_end(tc, labels);
                if (GET_REG(cur_op, 0) >= num_locals) {
                    cleanup_all(tc, labels);
                    MVM_exception_throw_adhoc(tc,
                        "Bytecode validation error: operand register index (%u) out of range; frame has %u locals; at byte %u",
                        GET_REG(cur_op, 0), num_locals, cur_op - bytecode_start);
                }
                if (op_type == MVM_operand_type_var) {
                    if (operand_type_var) {
                        /* XXX assume only one type variable */
                        if ((static_frame->local_types[GET_REG(cur_op, 0)] << 3) != operand_type_var) {
                            cleanup_all(tc, labels);
                            MVM_exception_throw_adhoc(tc,
                                "Bytecode validation error: inconsistent operand types %d and %d to op '%s' with a type variable, at instruction %d",
                                    static_frame->local_types[GET_REG(cur_op, 0)], operand_type_var >> 3, op_info->name, instruction);
                        }
                    }
                    else {
                        operand_type_var = (static_frame->local_types[GET_REG(cur_op, 0)] << 3);
                    }
                }
                else if ((static_frame->local_types[GET_REG(cur_op, 0)] << 3) != op_type) {
Exemplo n.º 21
0
void main(int argc, char **argv)
{
Errcode err;
UBYTE oldconfig;
static Argparse_list apl[] = {
	ARGP(apl,0,"-flic",get_flic_arg),
	ARGP(apl,APLAST,"-poc",get_poco_arg),
};

	if((err = init_pj_startup(apl,get_rest_of_command_line,argc,argv,
							  "pj_help","aa.mu")) < Success)
	{
		goto error;
	}
	oldconfig = err;


	add_local_pdr(&fli_local_pdr);
	add_local_pdr(&pic_local_pdr);
	set_hotkey_func(do_pj_hotkey); /* set input hot key function */

	/* initialize pj resource files */

	if((err = init_pj_resources()) < Success)
		goto error;

	if((err = init_ptools()) < Success) /* initialize tools */
		goto error;
	if((err = init_inks()) < Success) /* load any loadable inks */
		goto error;

	if(cl_poco_name != NULL)
	{
		if ((err = compile_cl_poco(cl_poco_name)) < Success)
		{
			if (err == Err_in_err_file)
				po_file_to_stdout(poco_err_name);
			err = Err_reported;
			goto error;
		}
	}

	vs = default_vs; /* copy in default settings */


	if((err = open_pj_startup_screen(init_after_screen)) < Success)
		goto error;

#ifdef WIDGET
	widge_ask = TRUE;
#endif /* WIDGET */

	if(!oldconfig)
		soft_continu_box("newconfig");

	if (cl_flic_name != NULL)
		pj_delete(tflxname);	  /* Delete old tempflx */

	if((err = force_temp_files()) < Success)
		goto error;

	if (cl_flic_name != NULL)
		resize_load_fli(cl_flic_name);

	err = go_vpaint();

	for(;;)
	{
		switch(err)
		{
			case RESET_SCREEN_SIZE:
				err = resize_screen();
				break;
			case RESET_NEW_SIZE:
			case KILL_NEW_SIZE:
				scrub_cur_frame();	/* clean up act in case user aborts */
				flush_tflx();
				err = resize_pencel(FALSE,err == RESET_NEW_SIZE);
				break;
			case RESET_DEFAULT_FLX:
				push_close_toscreen();
				if((err = clear_vtemps(TRUE)) < 0)
					goto error;
				if((err = open_default_flx()) < 0)
					goto error;
			case RESTART_VPAINT:
				err = go_vpaint();
				break;
			case EXIT_SYSTEM:
				outofhere(TRUE); /* we've exited, don't need to break... */
			case QUIT_SYSTEM:
				outofhere(FALSE);
			default: /* not a good return */
				goto error;
		}
	}
error:
	cleanup_all(err);
	exit(err);
}
Exemplo n.º 22
0
 DLL_EXPORT void cleanup() {
   cleanup_all();
 }
Exemplo n.º 23
0
static void cleanup_sig(int sig)
{
    cleanup_all();
    exit(sig);
}
Exemplo n.º 24
0
void _debugFree(void *memoryParameter, int tag)
{
	
	unsigned char *memory;
	struct chunkHeader *chunkHeader;
	struct chunkTrailer *chunkTrailer;
	struct chunkHeader *walker;
	struct chunkHeader *previous;

	memory = memoryParameter;
	chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader));

	if (chunkHeader->magicNumber != MAGIC_NUMBER)
	{
		dbgf( DBGL_SYS, DBGT_ERR, 
		     "invalid magic number in header: %08x, malloc tag = %d, free tag = %d", 
		     chunkHeader->magicNumber, chunkHeader->tag, tag );
		cleanup_all( -500080 );
	}

	previous = NULL;

	for (walker = chunkList; walker != NULL; walker = walker->next)
	{
		if (walker == chunkHeader)
			break;

		previous = walker;
	}

	if (walker == NULL)
	{
		dbg( DBGL_SYS, DBGT_ERR, "Double free detected, malloc tag = %d, free tag = %d", 
		     chunkHeader->tag, tag );
		cleanup_all( -500081 );
	}

	if (previous == NULL)
		chunkList = walker->next;

	else
		previous->next = walker->next;


	chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length);

	if (chunkTrailer->magicNumber != MAGIC_NUMBER)
	{
		dbgf( DBGL_SYS, DBGT_ERR, 
		     "invalid magic number in trailer: %08x, malloc tag = %d, free tag = %d",
		     chunkTrailer->magicNumber, chunkHeader->tag, tag );
		cleanup_all( -500082 );
	}

#ifdef MEMORY_USAGE

	removeMemory( chunkHeader->tag, tag );

#endif

	free(chunkHeader);
	

}
Exemplo n.º 25
0
/* Loads the extension op records. */
static MVMExtOpRecord * deserialize_extop_records(MVMThreadContext *tc, MVMCompUnit *cu, ReaderState *rs) {
    MVMExtOpRecord *extops;
    MVMuint32 num = rs->expected_extops;
    MVMuint8 *pos;
    MVMuint32 i;

    if (num == 0)
        return NULL;

    extops = MVM_calloc(num, sizeof *extops);

    pos = rs->extop_seg;
    for (i = 0; i < num; i++) {
        MVMuint32 name_idx;
        MVMuint16 operand_bytes = 0;
        MVMuint8 *operand_descriptor = extops[i].operand_descriptor;

        /* Read name string index. */
        ensure_can_read(tc, cu, rs, pos, 4);
        name_idx = read_int32(pos, 0);
        pos += 4;

        /* Lookup name string. */
        if (name_idx >= cu->body.num_strings) {
            cleanup_all(tc, rs);
            MVM_exception_throw_adhoc(tc,
                    "String heap index beyond end of string heap");
        }
        extops[i].name = MVM_cu_string(tc, cu, name_idx);

        /* Read operand descriptor. */
        ensure_can_read(tc, cu, rs, pos, 8);
        memcpy(operand_descriptor, pos, 8);
        pos += 8;

        /* Validate operand descriptor.
         * TODO: Unify with validation in MVM_ext_register_extop? */
        {
            MVMuint8 j = 0;

            for(; j < 8; j++) {
                MVMuint8 flags = operand_descriptor[j];

                if (!flags)
                    break;

                switch (flags & MVM_operand_rw_mask) {
                    case MVM_operand_literal:
                        goto check_literal;

                    case MVM_operand_read_reg:
                    case MVM_operand_write_reg:
                        operand_bytes += 2;
                        goto check_reg;

                    case MVM_operand_read_lex:
                    case MVM_operand_write_lex:
                        operand_bytes += 4;
                        goto check_reg;

                    default:
                        goto fail;
                }

            check_literal:
                switch (flags & MVM_operand_type_mask) {
                    case MVM_operand_int8:
                        operand_bytes += 1;
                        continue;

                    case MVM_operand_int16:
                        operand_bytes += 2;
                        continue;

                    case MVM_operand_int32:
                        operand_bytes += 4;
                        continue;

                    case MVM_operand_int64:
                        operand_bytes += 8;
                        continue;

                    case MVM_operand_num32:
                        operand_bytes += 4;
                        continue;

                    case MVM_operand_num64:
                        operand_bytes += 8;
                        continue;

                    case MVM_operand_str:
                        operand_bytes += 2;
                        continue;

                    case MVM_operand_coderef:
                        operand_bytes += 2;
                        continue;

                    case MVM_operand_ins:
                    case MVM_operand_callsite:
                    default:
                        goto fail;
                }

            check_reg:
                switch (flags & MVM_operand_type_mask) {
                    case MVM_operand_int8:
                    case MVM_operand_int16:
                    case MVM_operand_int32:
                    case MVM_operand_int64:
                    case MVM_operand_num32:
                    case MVM_operand_num64:
                    case MVM_operand_str:
                    case MVM_operand_obj:
                    case MVM_operand_type_var:
                    case MVM_operand_uint8:
                    case MVM_operand_uint16:
                    case MVM_operand_uint32:
                    case MVM_operand_uint64:
                        continue;

                    default:
                        goto fail;
                }

            fail:
                cleanup_all(tc, rs);
                MVM_exception_throw_adhoc(tc, "Invalid operand descriptor");
            }
        }

        extops[i].operand_bytes = operand_bytes;
    }

    return extops;
}
Exemplo n.º 26
0
Arquivo: avl.c Projeto: axn/bmxd
static void avl_test()
{


        struct avl_node *an = NULL;
        AVL_TREE(t, sizeof (int));

        int i;

        struct p {
                int i;
                int v;
        };
        struct p * p;


        for (i = 0; i <= 19; i++) {
                p = debugMalloc(sizeof ( struct p), 999);
                p->i = i;
                p->v = 0;
                avl_insert(&t, p);
        }


        for (i = 19; i >= 10; i--) {
                p = avl_remove(&t, &i);
                printf(" removed %d/%d\n", p->i, p->v );
                debugFree( p, 1999 );
        }

        for (i = 9; i >= 0; i--) {
                p = debugMalloc(sizeof ( struct p), 999);
                p->i = i;
                p->v = 1;
                avl_insert(&t, p);
        }

        for (i = 5; i <= 15; i++) {
                p = debugMalloc(sizeof ( struct p), 999);
                p->i = i;
                p->v = 2;
                avl_insert(&t, p);
        }

        for (i = 3; i <= 9; i++) {
                p = debugMalloc(sizeof ( struct p), 999);
                p->i = 2;
                p->v = i;
                avl_insert(&t, p);
        }

        printf("\navl_iterate():\n");
        i=0;
        an = NULL;
        while( (an = avl_iterate( &t, an ) ) ) {
                p = ((struct p*)(an->key));
                if ( i > p->i)
                        printf("\nERROR %d > %d \n", i, p->i);
                i = p->i;
                printf( "%3d/%1d ", p->i, p->v );
        }
        printf("\n");

#ifdef AVL_DEBUG
        printf("avl_debug():\n");
        avl_debug( &t );
#endif


        for (i = 9; i >= 3; i--) {
                int v = 2;
                if ((p = avl_remove(&t, &v)) ) {
                        printf(" removed %d/%d\n", p->i, p->v);
                        debugFree(p, 1999);
                }
        }


        for (i = 9; i >= 0; i--) {
                if ( (p = avl_remove(&t, &i) ) ) {
                        printf(" removed %d/%d\n", p->i, p->v);
                        debugFree(p, 1999);
                }
        }

        for (i = 0; i <= 19; i++) {
                if ((p = avl_remove(&t, &i))) {
                        printf(" removed %d/%d\n", p->i, p->v);
                        debugFree(p, 1999);
                } else {
                        printf(" failed rm %d\n", i);
                }
        }







/*        for (i = 20; i >= 0; i--) {

                p = debugMalloc(sizeof ( struct p), 999);
                p->i = i;
                p->v = 5;
                avl_insert(&t, p);
        }
*/

        i = 0;

        printf("\n");


        printf("\navl_next():\n");

        int32_t j = 0;
        while( (an = avl_next( &t,  &j )) ) {
                p = ((struct p*)(an->key));
                j = p->i;
                if ( i > p->i)
                        printf("\nERROR %d > %d \n", i, p->i);

                i = p->i;

                printf( "N%4d/%1d ", p->i, p->v );

                if ( i%10 == 0 )
                        printf("\n");

        }


        printf("\navl_iterate():\n");
        i=0;
        while( (an = avl_iterate( &t, an ) ) ) {
                p = ((struct p*)(an->key));
                if ( i > p->i)
                        printf("\nERROR %d > %d \n", i, p->i);
                i = p->i;
                printf( "%3d/%1d ", p->i, p->v );
        }
        printf("\n");

#ifdef AVL_DEBUG
        printf("avl_debug():\n");
        avl_debug( &t );
#endif



        while( t.root ) {
                p = (struct p*)t.root->key;
                p = avl_remove( &t, p );
                printf(" removed %d/%d\n", p->i, p->v );
                debugFree( p, 1999 );

        }

        printf("\n");

        cleanup_all(CLEANUP_SUCCESS);


}